react-laravel-sanctum/dist/index.cjs

Easily integrate Laravel Sanctum and Breeze authentication into your React app.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  AuthProvider: () => AuthProvider,
  useAuth: () => useAuth
});
module.exports = __toCommonJS(index_exports);

// src/context/AuthProvider.tsx
var import_react = require("react");
var import_jsx_runtime = require("react/jsx-runtime");
var AuthContext = (0, import_react.createContext)(void 0);
function AuthProvider({ children, emailVerification = true, config }) {
  const axiosInstance = (0, import_react.useMemo)(() => config.axiosInstance, [config.axiosInstance]);
  const { signInRoute, signUpRoute, authenticationCheckRoute, sendEmailVerificationRoute, verifyEmailRoute, signOutRoute } = config;
  const [authenticationState, setAuthenticationState] = (0, import_react.useState)({
    user: null,
    authenticated: null,
    verified: null
  });
  const [loading, setLoading] = (0, import_react.useState)(true);
  const { user, authenticated, verified } = authenticationState;
  (0, import_react.useEffect)(() => {
    checkAuthentication();
  }, []);
  const signIn = (credentials) => {
    return new Promise(async (resolve, reject) => {
      try {
        await axiosInstance.post(signInRoute, credentials);
        const user2 = await revalidate();
        resolve({ mustVerifyEmail: false, signedIn: true, user: user2 });
      } catch (error) {
        if (error.response?.status === 409 && emailVerification) {
          setAuthenticationState({ user: null, authenticated: true, verified: false });
          resolve({ mustVerifyEmail: true, signedIn: false });
        } else {
          reject(error);
        }
      }
    });
  };
  const signUp = (credentials) => {
    return new Promise(async (resolve, reject) => {
      try {
        if (!signUpRoute) {
          return reject(new Error("signUpRoute is not defined"));
        }
        await axiosInstance.post(signUpRoute, credentials);
        if (emailVerification) {
          setAuthenticationState({ user: null, authenticated: true, verified: false });
          resolve({ mustVerifyEmail: true, signedIn: false });
        } else {
          const user2 = await revalidate();
          resolve({ mustVerifyEmail: false, signedIn: true, user: user2 });
        }
      } catch (error) {
        reject(error);
      }
    });
  };
  const revalidate = () => {
    return new Promise(async (resolve, reject) => {
      try {
        const { data: user2 } = await axiosInstance.get(authenticationCheckRoute);
        setAuthenticationState({ user: user2, authenticated: true, verified: true });
        resolve(user2);
      } catch (error) {
        if (error.response?.status === 401) {
          setAuthenticationState({ user: null, authenticated: false, verified: null });
          resolve({});
        } else if (error.response?.status === 409) {
          setAuthenticationState({ user: null, authenticated: true, verified: false });
          resolve({});
        } else {
          reject(error);
        }
      }
    });
  };
  const handleSessionTimeout = (error) => {
    if (error.response?.status === 401 || error.response?.status === 409) {
      setAuthenticationState({ user: null, authenticated: false, verified: false });
    }
  };
  const verifyEmail = (id, hash, expires, signature) => {
    return new Promise(async (resolve, reject) => {
      try {
        const url = verifyEmailRoute?.(id, hash, expires, signature);
        if (!url) {
          return reject(new Error("verifyEmailRoute is not defined"));
        }
        await axiosInstance.get(url);
        const user2 = await revalidate();
        resolve(user2);
      } catch (error) {
        reject(error);
      }
    });
  };
  const sendEmailVerification = () => {
    return new Promise(async (resolve, reject) => {
      try {
        if (!sendEmailVerificationRoute) {
          return reject(new Error("sendEmailVerificationRoute is not defined"));
        }
        await axiosInstance.post(sendEmailVerificationRoute);
        resolve();
      } catch (error) {
        reject(error);
      }
    });
  };
  const signOut = () => {
    return new Promise(async (resolve, reject) => {
      try {
        await axiosInstance.post(signOutRoute);
        setAuthenticationState({ user: null, authenticated: false, verified: false });
        resolve();
      } catch (error) {
        reject(error);
      }
    });
  };
  const checkAuthentication = () => {
    return new Promise(async (resolve, reject) => {
      setLoading(true);
      if (authenticated === null || verified === null) {
        try {
          await revalidate();
          resolve(true);
        } catch (error) {
          if (error.response?.status === 401) {
            setAuthenticationState({ user: null, authenticated: false, verified: null });
            resolve(false);
          } else if (error.response?.status === 409) {
            setAuthenticationState({ user: null, authenticated: true, verified: false });
            resolve(false);
          } else {
            reject(error);
          }
        } finally {
          setLoading(false);
        }
      } else {
        resolve(authenticated);
      }
    });
  };
  const setUser = (user2, authenticated2, verified2) => {
    setAuthenticationState({ user: user2, authenticated: authenticated2, verified: verified2 });
  };
  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
    AuthContext.Provider,
    {
      value: {
        authenticated,
        user,
        verified,
        loading,
        setUser,
        signIn,
        signUp,
        verifyEmail,
        sendEmailVerification,
        signOut,
        handleSessionTimeout
      },
      children
    }
  );
}
var useAuth = () => {
  const context = (0, import_react.useContext)(AuthContext);
  if (!context) throw new Error("useAuth should only be used inside <AuthProvider/>");
  return context;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AuthProvider,
  useAuth
});