@riligar/auth-react 1.0.4

package/dist/index.esm.js

@@ -0,0 +1,828 @@
+import require$$0, { useEffect, createContext } from 'react';
+import { Navigate, Outlet } from 'react-router-dom';
+
+// Ajuste se o back-end estiver em outro domínio/porta
+const API_BASE = typeof window !== 'undefined' && window?.location ? import.meta?.env?.VITE_API_BASE ?? "http://localhost:3000" : "http://localhost:3000";
+
+// helper fetch pré-configurado
+async function api(route, opts = {}) {
+  const token = getStoredToken();
+  const headers = {
+    "Content-Type": "application/json",
+    ...opts.headers
+  };
+
+  // Adiciona Authorization header se tiver token
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  const res = await fetch(`${API_BASE}${route}`, {
+    headers,
+    ...opts
+  });
+
+  // Converte JSON automaticamente e lança erro legível
+  const data = res.status !== 204 ? await res.json().catch(() => ({})) : null;
+  if (!res.ok) throw Object.assign(new Error(data?.error ?? res.statusText), {
+    res,
+    data
+  });
+  return data;
+}
+
+// Gerenciamento de token no localStorage
+function getStoredToken() {
+  if (typeof window === 'undefined') return null;
+  return window.localStorage.getItem('auth:token');
+}
+function setStoredToken(token) {
+  if (typeof window === 'undefined') return;
+  if (token) {
+    window.localStorage.setItem('auth:token', token);
+  } else {
+    window.localStorage.removeItem('auth:token');
+  }
+}
+
+// Decodifica JWT (apenas payload, sem verificação de assinatura)
+function decodeJWT(token) {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(atob(parts[1].replace(/-/g, '+').replace(/_/g, '/')));
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+// Verifica se o token está expirado
+function isTokenExpired(token) {
+  const payload = decodeJWT(token);
+  if (!payload || !payload.exp) return true;
+  return Date.now() >= payload.exp * 1000;
+}
+
+// Verifica se o usuário está autenticado
+function isAuthenticated() {
+  const token = getStoredToken();
+  return token && !isTokenExpired(token);
+}
+
+// Obtém dados do usuário do token
+function getCurrentUser() {
+  const token = getStoredToken();
+  if (!token || isTokenExpired(token)) return null;
+  const payload = decodeJWT(token);
+  return payload ? {
+    id: payload.sub,
+    email: payload.email,
+    name: payload.name,
+    ...payload
+  } : null;
+}
+
+/*--- métodos de autenticação-------------------*/
+const signUp = async (email, password) => {
+  const result = await api("/auth/sign-up", {
+    method: "POST",
+    body: JSON.stringify({
+      email,
+      password
+    })
+  });
+  if (result.token) {
+    setStoredToken(result.token);
+  }
+  return result;
+};
+const signIn = async (email, password) => {
+  const result = await api("/auth/sign-in", {
+    method: "POST",
+    body: JSON.stringify({
+      email,
+      password
+    })
+  });
+  if (result.token) {
+    setStoredToken(result.token);
+  }
+  return result;
+};
+const signOut = async () => {
+  try {
+    await api("/auth/sign-out", {
+      method: "POST"
+    });
+  } catch {
+    // Ignora erros de logout no servidor
+  } finally {
+    setStoredToken(null);
+  }
+};
+const refreshToken = async () => {
+  try {
+    const result = await api("/auth/refresh", {
+      method: "POST"
+    });
+    if (result.token) {
+      setStoredToken(result.token);
+      return result;
+    }
+  } catch (error) {
+    setStoredToken(null);
+    throw error;
+  }
+};
+
+/* Social login redirect (ex.: Google) ---------*/
+function socialRedirect(provider, redirectTo = typeof window !== 'undefined' ? window.location.href : '/') {
+  if (typeof window === 'undefined') return;
+  // Melhor pegar a URL de redirect dada pelo back-end, mas isso já funciona:
+  window.location = `${API_BASE}/auth/sign-in/${provider}?redirect=${encodeURIComponent(redirectTo)}`;
+}
+
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => {
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      console.warn(
+        "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+      );
+    }
+    listeners.clear();
+  };
+  const api = { setState, getState, getInitialState, subscribe, destroy };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var withSelector = {exports: {}};
+
+var withSelector_production = {};
+
+var shim = {exports: {}};
+
+var useSyncExternalStoreShim_production = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_production;
+
+function requireUseSyncExternalStoreShim_production () {
+	if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
+	hasRequiredUseSyncExternalStoreShim_production = 1;
+	var React = require$$0;
+	function is(x, y) {
+	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is,
+	  useState = React.useState,
+	  useEffect = React.useEffect,
+	  useLayoutEffect = React.useLayoutEffect,
+	  useDebugValue = React.useDebugValue;
+	function useSyncExternalStore$2(subscribe, getSnapshot) {
+	  var value = getSnapshot(),
+	    _useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
+	    inst = _useState[0].inst,
+	    forceUpdate = _useState[1];
+	  useLayoutEffect(
+	    function () {
+	      inst.value = value;
+	      inst.getSnapshot = getSnapshot;
+	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	    },
+	    [subscribe, value, getSnapshot]
+	  );
+	  useEffect(
+	    function () {
+	      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	      return subscribe(function () {
+	        checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	      });
+	    },
+	    [subscribe]
+	  );
+	  useDebugValue(value);
+	  return value;
+	}
+	function checkIfSnapshotChanged(inst) {
+	  var latestGetSnapshot = inst.getSnapshot;
+	  inst = inst.value;
+	  try {
+	    var nextValue = latestGetSnapshot();
+	    return !objectIs(inst, nextValue);
+	  } catch (error) {
+	    return true;
+	  }
+	}
+	function useSyncExternalStore$1(subscribe, getSnapshot) {
+	  return getSnapshot();
+	}
+	var shim =
+	  "undefined" === typeof window ||
+	  "undefined" === typeof window.document ||
+	  "undefined" === typeof window.document.createElement
+	    ? useSyncExternalStore$1
+	    : useSyncExternalStore$2;
+	useSyncExternalStoreShim_production.useSyncExternalStore =
+	  void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+	return useSyncExternalStoreShim_production;
+}
+
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_development;
+
+function requireUseSyncExternalStoreShim_development () {
+	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+	hasRequiredUseSyncExternalStoreShim_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function is(x, y) {
+	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	    }
+	    function useSyncExternalStore$2(subscribe, getSnapshot) {
+	      didWarnOld18Alpha ||
+	        void 0 === React.startTransition ||
+	        ((didWarnOld18Alpha = true),
+	        console.error(
+	          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+	        ));
+	      var value = getSnapshot();
+	      if (!didWarnUncachedGetSnapshot) {
+	        var cachedValue = getSnapshot();
+	        objectIs(value, cachedValue) ||
+	          (console.error(
+	            "The result of getSnapshot should be cached to avoid an infinite loop"
+	          ),
+	          (didWarnUncachedGetSnapshot = true));
+	      }
+	      cachedValue = useState({
+	        inst: { value: value, getSnapshot: getSnapshot }
+	      });
+	      var inst = cachedValue[0].inst,
+	        forceUpdate = cachedValue[1];
+	      useLayoutEffect(
+	        function () {
+	          inst.value = value;
+	          inst.getSnapshot = getSnapshot;
+	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	        },
+	        [subscribe, value, getSnapshot]
+	      );
+	      useEffect(
+	        function () {
+	          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	          return subscribe(function () {
+	            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
+	          });
+	        },
+	        [subscribe]
+	      );
+	      useDebugValue(value);
+	      return value;
+	    }
+	    function checkIfSnapshotChanged(inst) {
+	      var latestGetSnapshot = inst.getSnapshot;
+	      inst = inst.value;
+	      try {
+	        var nextValue = latestGetSnapshot();
+	        return !objectIs(inst, nextValue);
+	      } catch (error) {
+	        return true;
+	      }
+	    }
+	    function useSyncExternalStore$1(subscribe, getSnapshot) {
+	      return getSnapshot();
+	    }
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+	    var React = require$$0,
+	      objectIs = "function" === typeof Object.is ? Object.is : is,
+	      useState = React.useState,
+	      useEffect = React.useEffect,
+	      useLayoutEffect = React.useLayoutEffect,
+	      useDebugValue = React.useDebugValue,
+	      didWarnOld18Alpha = false,
+	      didWarnUncachedGetSnapshot = false,
+	      shim =
+	        "undefined" === typeof window ||
+	        "undefined" === typeof window.document ||
+	        "undefined" === typeof window.document.createElement
+	          ? useSyncExternalStore$1
+	          : useSyncExternalStore$2;
+	    useSyncExternalStoreShim_development.useSyncExternalStore =
+	      void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	  })();
+	return useSyncExternalStoreShim_development;
+}
+
+var hasRequiredShim;
+
+function requireShim () {
+	if (hasRequiredShim) return shim.exports;
+	hasRequiredShim = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  shim.exports = requireUseSyncExternalStoreShim_production();
+	} else {
+	  shim.exports = requireUseSyncExternalStoreShim_development();
+	}
+	return shim.exports;
+}
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredWithSelector_production;
+
+function requireWithSelector_production () {
+	if (hasRequiredWithSelector_production) return withSelector_production;
+	hasRequiredWithSelector_production = 1;
+	var React = require$$0,
+	  shim = requireShim();
+	function is(x, y) {
+	  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is,
+	  useSyncExternalStore = shim.useSyncExternalStore,
+	  useRef = React.useRef,
+	  useEffect = React.useEffect,
+	  useMemo = React.useMemo,
+	  useDebugValue = React.useDebugValue;
+	withSelector_production.useSyncExternalStoreWithSelector = function (
+	  subscribe,
+	  getSnapshot,
+	  getServerSnapshot,
+	  selector,
+	  isEqual
+	) {
+	  var instRef = useRef(null);
+	  if (null === instRef.current) {
+	    var inst = { hasValue: false, value: null };
+	    instRef.current = inst;
+	  } else inst = instRef.current;
+	  instRef = useMemo(
+	    function () {
+	      function memoizedSelector(nextSnapshot) {
+	        if (!hasMemo) {
+	          hasMemo = true;
+	          memoizedSnapshot = nextSnapshot;
+	          nextSnapshot = selector(nextSnapshot);
+	          if (void 0 !== isEqual && inst.hasValue) {
+	            var currentSelection = inst.value;
+	            if (isEqual(currentSelection, nextSnapshot))
+	              return (memoizedSelection = currentSelection);
+	          }
+	          return (memoizedSelection = nextSnapshot);
+	        }
+	        currentSelection = memoizedSelection;
+	        if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+	        var nextSelection = selector(nextSnapshot);
+	        if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+	          return (memoizedSnapshot = nextSnapshot), currentSelection;
+	        memoizedSnapshot = nextSnapshot;
+	        return (memoizedSelection = nextSelection);
+	      }
+	      var hasMemo = false,
+	        memoizedSnapshot,
+	        memoizedSelection,
+	        maybeGetServerSnapshot =
+	          void 0 === getServerSnapshot ? null : getServerSnapshot;
+	      return [
+	        function () {
+	          return memoizedSelector(getSnapshot());
+	        },
+	        null === maybeGetServerSnapshot
+	          ? void 0
+	          : function () {
+	              return memoizedSelector(maybeGetServerSnapshot());
+	            }
+	      ];
+	    },
+	    [getSnapshot, getServerSnapshot, selector, isEqual]
+	  );
+	  var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+	  useEffect(
+	    function () {
+	      inst.hasValue = true;
+	      inst.value = value;
+	    },
+	    [value]
+	  );
+	  useDebugValue(value);
+	  return value;
+	};
+	return withSelector_production;
+}
+
+var withSelector_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredWithSelector_development;
+
+function requireWithSelector_development () {
+	if (hasRequiredWithSelector_development) return withSelector_development;
+	hasRequiredWithSelector_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function is(x, y) {
+	      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+	    }
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+	    var React = require$$0,
+	      shim = requireShim(),
+	      objectIs = "function" === typeof Object.is ? Object.is : is,
+	      useSyncExternalStore = shim.useSyncExternalStore,
+	      useRef = React.useRef,
+	      useEffect = React.useEffect,
+	      useMemo = React.useMemo,
+	      useDebugValue = React.useDebugValue;
+	    withSelector_development.useSyncExternalStoreWithSelector = function (
+	      subscribe,
+	      getSnapshot,
+	      getServerSnapshot,
+	      selector,
+	      isEqual
+	    ) {
+	      var instRef = useRef(null);
+	      if (null === instRef.current) {
+	        var inst = { hasValue: false, value: null };
+	        instRef.current = inst;
+	      } else inst = instRef.current;
+	      instRef = useMemo(
+	        function () {
+	          function memoizedSelector(nextSnapshot) {
+	            if (!hasMemo) {
+	              hasMemo = true;
+	              memoizedSnapshot = nextSnapshot;
+	              nextSnapshot = selector(nextSnapshot);
+	              if (void 0 !== isEqual && inst.hasValue) {
+	                var currentSelection = inst.value;
+	                if (isEqual(currentSelection, nextSnapshot))
+	                  return (memoizedSelection = currentSelection);
+	              }
+	              return (memoizedSelection = nextSnapshot);
+	            }
+	            currentSelection = memoizedSelection;
+	            if (objectIs(memoizedSnapshot, nextSnapshot))
+	              return currentSelection;
+	            var nextSelection = selector(nextSnapshot);
+	            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+	              return (memoizedSnapshot = nextSnapshot), currentSelection;
+	            memoizedSnapshot = nextSnapshot;
+	            return (memoizedSelection = nextSelection);
+	          }
+	          var hasMemo = false,
+	            memoizedSnapshot,
+	            memoizedSelection,
+	            maybeGetServerSnapshot =
+	              void 0 === getServerSnapshot ? null : getServerSnapshot;
+	          return [
+	            function () {
+	              return memoizedSelector(getSnapshot());
+	            },
+	            null === maybeGetServerSnapshot
+	              ? void 0
+	              : function () {
+	                  return memoizedSelector(maybeGetServerSnapshot());
+	                }
+	          ];
+	        },
+	        [getSnapshot, getServerSnapshot, selector, isEqual]
+	      );
+	      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+	      useEffect(
+	        function () {
+	          inst.hasValue = true;
+	          inst.value = value;
+	        },
+	        [value]
+	      );
+	      useDebugValue(value);
+	      return value;
+	    };
+	    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+	      "function" ===
+	        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
+	      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	  })();
+	return withSelector_development;
+}
+
+if (process.env.NODE_ENV === 'production') {
+  withSelector.exports = requireWithSelector_production();
+} else {
+  withSelector.exports = requireWithSelector_development();
+}
+
+var withSelectorExports = withSelector.exports;
+var useSyncExternalStoreExports = /*@__PURE__*/getDefaultExportFromCjs(withSelectorExports);
+
+const { useDebugValue } = require$$0;
+const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports;
+let didWarnAboutEqualityFn = false;
+const identity = (arg) => arg;
+function useStore(api, selector = identity, equalityFn) {
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && equalityFn && !didWarnAboutEqualityFn) {
+    console.warn(
+      "[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
+    );
+    didWarnAboutEqualityFn = true;
+  }
+  const slice = useSyncExternalStoreWithSelector(
+    api.subscribe,
+    api.getState,
+    api.getServerState || api.getInitialState,
+    selector,
+    equalityFn
+  );
+  useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && typeof createState !== "function") {
+    console.warn(
+      "[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
+    );
+  }
+  const api = typeof createState === "function" ? createStore(createState) : createState;
+  const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = (createState) => createState ? createImpl(createState) : createImpl;
+
+// Estado: { user, loading, error }
+const useAuthStore = create((set, get) => ({
+  user: null,
+  loading: true,
+  error: null,
+  /* Init ao montar o Provider */
+  init: async () => {
+    try {
+      // Verifica se há um token válido e obtém dados do usuário
+      if (isAuthenticated()) {
+        const user = getCurrentUser();
+        set({
+          user,
+          loading: false
+        });
+      } else {
+        set({
+          user: null,
+          loading: false
+        });
+      }
+    } catch (error) {
+      console.error('Erro na inicialização:', error);
+      set({
+        user: null,
+        loading: false
+      });
+    }
+  },
+  /* Ações */
+  signUp: async (email, password) => {
+    set({
+      loading: true,
+      error: null
+    });
+    try {
+      const result = await signUp(email, password);
+      const user = getCurrentUser();
+      set({
+        user,
+        loading: false
+      });
+      return result;
+    } catch (err) {
+      set({
+        error: err,
+        loading: false
+      });
+      throw err;
+    }
+  },
+  signIn: async (email, password) => {
+    set({
+      loading: true,
+      error: null
+    });
+    try {
+      const result = await signIn(email, password);
+      const user = getCurrentUser();
+      set({
+        user,
+        loading: false
+      });
+      return result;
+    } catch (err) {
+      set({
+        error: err,
+        loading: false
+      });
+      throw err;
+    }
+  },
+  signOut: async () => {
+    await signOut();
+    set({
+      user: null
+    });
+    // Sincronizar logout entre abas
+    if (typeof window !== 'undefined') {
+      window.localStorage.setItem("auth:logout", Date.now());
+    }
+  },
+  /* Refresh do token em background */
+  startRefresh: () => {
+    if (typeof window === 'undefined') return;
+    const refreshInterval = setInterval(async () => {
+      try {
+        // Se o usuário está autenticado mas o token está próximo do vencimento
+        if (isAuthenticated()) {
+          const token = window.localStorage.getItem('auth:token');
+          if (token) {
+            // Decodifica o token para verificar tempo de expiração
+            const payload = JSON.parse(atob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/')));
+            const now = Date.now() / 1000;
+            const timeUntilExpiry = payload.exp - now;
+
+            // Se o token expira em menos de 5 minutos, faz refresh
+            if (timeUntilExpiry < 300) {
+              // 5 minutos
+              await refreshToken();
+              const user = getCurrentUser();
+              set({
+                user
+              });
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Erro no refresh automático:', error);
+        // Em caso de erro, faz logout
+        set({
+          user: null
+        });
+        window.localStorage.removeItem('auth:token');
+      }
+    }, 4 * 60 * 1000); // Verifica a cada 4 minutos
+
+    // Limpa o intervalo quando necessário
+    if (typeof window !== 'undefined') {
+      window.addEventListener('beforeunload', () => {
+        clearInterval(refreshInterval);
+      });
+    }
+  },
+  /* Verifica se o token ainda é válido */
+  checkTokenValidity: () => {
+    if (!isAuthenticated()) {
+      set({
+        user: null
+      });
+      return false;
+    }
+    return true;
+  }
+}));
+
+const AuthContext = /*#__PURE__*/createContext(); // só para ter o Provider em JSX
+
+function AuthProvider({
+  children
+}) {
+  const init = useAuthStore(s => s.init);
+  const startRefresh = useAuthStore(s => s.startRefresh);
+  const checkTokenValidity = useAuthStore(s => s.checkTokenValidity);
+  useEffect(() => {
+    init();
+    startRefresh();
+  }, [init, startRefresh]);
+
+  // Sincronização entre abas - escuta logout e mudanças no token
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+    const handleStorageChange = event => {
+      if (event.key === "auth:logout") {
+        window.location.reload();
+      }
+      // Se o token mudou em outra aba, recarrega
+      if (event.key === "auth:token") {
+        checkTokenValidity();
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [checkTokenValidity]);
+
+  // Verifica validade do token periodicamente
+  useEffect(() => {
+    if (typeof window === 'undefined') return;
+    const interval = setInterval(() => {
+      checkTokenValidity();
+    }, 30 * 1000); // Verifica a cada 30 segundos
+
+    return () => clearInterval(interval);
+  }, [checkTokenValidity]);
+  return /*#__PURE__*/React.createElement(AuthContext.Provider, {
+    value: null /* valor irrelevante */
+  }, children);
+}
+
+/* Hooks "facade" que a app vai usar */
+const useAuth = () => useAuthStore(s => ({
+  user: s.user,
+  loading: s.loading,
+  error: s.error,
+  isAuthenticated: s.user !== null
+}));
+const useSignIn = () => useAuthStore(s => s.signIn);
+const useSignUp = () => useAuthStore(s => s.signUp);
+const useSignOut = () => useAuthStore(s => s.signOut);
+const useCheckToken = () => useAuthStore(s => s.checkTokenValidity);
+
+function ProtectedRoute({
+  fallback = /*#__PURE__*/React.createElement("p", null, "\u231B Carregando..."),
+  redirectTo = "/login"
+}) {
+  const {
+    user,
+    loading
+  } = useAuth();
+  if (loading) return fallback;
+  if (!user) return /*#__PURE__*/React.createElement(Navigate, {
+    to: redirectTo,
+    replace: true
+  });
+  return /*#__PURE__*/React.createElement(Outlet, null);
+}
+
+export { AuthProvider, ProtectedRoute, getCurrentUser, isAuthenticated, refreshToken, signIn, signOut, signUp, socialRedirect, useAuth, useAuthStore, useCheckToken, useSignIn, useSignOut, useSignUp };
+//# sourceMappingURL=index.esm.js.map