@veliseev93/clerk-react-native 0.0.1-dev.0

package/dist/index.mjs

@@ -0,0 +1,611 @@
+// src/enums/api-error.ts
+var ClerkApiError = /* @__PURE__ */ ((ClerkApiError2) => {
+  ClerkApiError2["SESSION_EXISTS"] = "session_exists";
+  ClerkApiError2["FORM_IDENTIFIER_EXIST"] = "form_identifier_exists";
+  ClerkApiError2["FORM_CODE_INCORRECT"] = "form_code_incorrect";
+  return ClerkApiError2;
+})(ClerkApiError || {});
+
+// src/hooks/use-clerk-resources.ts
+import { getClerkInstance } from "@clerk/clerk-expo";
+var useClerkResources = () => {
+  const clerk = getClerkInstance();
+  const signUp = clerk.client?.signUp;
+  const signIn = clerk.client?.signIn;
+  const signOut = clerk.signOut;
+  const setActive = clerk.setActive;
+  return { signUp, signIn, setActive, signOut };
+};
+
+// src/hooks/use-get-session-token.ts
+import { getClerkInstance as getClerkInstance2 } from "@clerk/clerk-expo";
+var useGetSessionToken = () => {
+  const clerk = getClerkInstance2();
+  const getSessionToken = async ({ tokenTemplate }) => {
+    try {
+      const token = await clerk.session?.getToken({ template: tokenTemplate });
+      const sessionToken = token || clerk.session?.lastActiveToken?.getRawString();
+      if (sessionToken) {
+        return {
+          sessionToken,
+          isSuccess: true
+        };
+      } else {
+        return {
+          sessionToken: null,
+          isSuccess: false
+        };
+      }
+    } catch (error) {
+      return {
+        sessionToken: null,
+        error,
+        isSuccess: false
+      };
+    }
+  };
+  return { getSessionToken };
+};
+
+// src/hooks/use-auth-with-sso.ts
+import { useSSO } from "@clerk/clerk-expo";
+import { useState } from "react";
+function useAuthWithSSO() {
+  const { startSSOFlow: clerkStartSSOFlow } = useSSO();
+  const { getSessionToken } = useGetSessionToken();
+  const [isLoading, setIsLoading] = useState(false);
+  const startSSOFlow = async ({
+    strategy,
+    redirectUrl,
+    tokenTemplate
+  }) => {
+    try {
+      setIsLoading(true);
+      const { createdSessionId, setActive, signIn, signUp } = await clerkStartSSOFlow({
+        strategy,
+        redirectUrl
+      });
+      if (!createdSessionId) {
+        return { sessionToken: null };
+      }
+      await setActive?.({ session: createdSessionId });
+      const { sessionToken } = await getSessionToken({ tokenTemplate });
+      if (sessionToken) {
+        return {
+          sessionToken,
+          signIn,
+          signUp,
+          isSuccess: true
+        };
+      }
+      return {
+        signIn,
+        signUp,
+        isSuccess: false
+      };
+    } catch (error) {
+      return {
+        error,
+        isSuccess: false
+      };
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return { startSSOFlow, isLoading };
+}
+
+// src/hooks/use-auth-with-ticket.ts
+import { useState as useState2 } from "react";
+function useAuthWithTicket() {
+  const { signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isLoading, setIsLoading] = useState2(false);
+  const startAuthorization = async ({ ticket, tokenTemplate }) => {
+    if (signIn) {
+      setIsLoading(true);
+      try {
+        const signInAttempt = await signIn.create({
+          strategy: "ticket",
+          ticket
+        });
+        if (signInAttempt.status === "complete") {
+          await setActive({
+            session: signInAttempt.createdSessionId
+          });
+          const { sessionToken, error } = await getSessionToken({ tokenTemplate });
+          if (sessionToken) {
+            return {
+              sessionToken,
+              signIn,
+              isSuccess: true
+            };
+          }
+          return {
+            signIn,
+            error,
+            isSuccess: false
+          };
+        }
+      } catch (error) {
+        return {
+          signIn,
+          error,
+          isSuccess: false
+        };
+      } finally {
+        setIsLoading(false);
+      }
+    }
+    return {
+      sessionToken: null,
+      signIn,
+      isSuccess: false
+    };
+  };
+  return {
+    startAuthorization,
+    isLoading
+  };
+}
+
+// src/hooks/use-otp-verification.ts
+import { useState as useState3 } from "react";
+function useOtpVerification() {
+  const { signUp, signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isVerifying, setIsVerifying] = useState3(false);
+  const sendSignInOtpCode = async (strategy, isSecondFactor = false) => {
+    const codeFactors = isSecondFactor ? signIn?.supportedSecondFactors : signIn?.supportedFirstFactors;
+    const prepareFactor = isSecondFactor ? signIn?.prepareSecondFactor : signIn?.prepareFirstFactor;
+    const codeFactor = codeFactors?.find(
+      (factor) => factor.strategy === strategy
+    );
+    if (codeFactor && "emailAddressId" in codeFactor) {
+      await prepareFactor?.({ strategy: "email_code", emailAddressId: codeFactor.emailAddressId });
+    } else if (codeFactor && "phoneNumberId" in codeFactor) {
+      await prepareFactor?.({ strategy: "phone_code", phoneNumberId: codeFactor.phoneNumberId });
+    } else {
+      throw new Error(`No ${isSecondFactor ? "second " : ""}factor found for strategy: ${strategy}`);
+    }
+  };
+  const sendSignUpOtpCode = async (strategy) => {
+    if (!signUp) return;
+    await signUp.prepareVerification({ strategy });
+  };
+  const sendOtpCode = async ({ strategy, isSignUp, isSecondFactor }) => {
+    if (isSignUp) {
+      await sendSignUpOtpCode(strategy);
+    } else {
+      await sendSignInOtpCode(strategy, !!isSecondFactor);
+    }
+  };
+  const verifyCode = async ({
+    code,
+    strategy,
+    tokenTemplate,
+    isSignUp,
+    isSecondFactor
+  }) => {
+    try {
+      setIsVerifying(true);
+      if (isSignUp) {
+        const completeSignUp = await signUp?.attemptVerification({
+          strategy,
+          code
+        });
+        if (completeSignUp?.status === "complete") {
+          await setActive?.({ session: completeSignUp.createdSessionId });
+          const { sessionToken, error } = await getSessionToken({ tokenTemplate });
+          if (sessionToken) {
+            return {
+              sessionToken,
+              signIn,
+              signUp,
+              isSuccess: true
+            };
+          }
+          return {
+            signIn,
+            signUp,
+            error,
+            isSuccess: false
+          };
+        }
+      } else {
+        const attemptSignIn = isSecondFactor ? signIn?.attemptSecondFactor : signIn?.attemptFirstFactor;
+        const completeSignIn = await attemptSignIn?.({ strategy, code });
+        if (completeSignIn?.status === "complete") {
+          await setActive?.({ session: completeSignIn.createdSessionId });
+          const sessionToken = (await getSessionToken({ tokenTemplate })).sessionToken;
+          if (sessionToken) {
+            return { sessionToken, signIn, signUp, isSuccess: true };
+          }
+          return { sessionToken: null, signIn, signUp, isSuccess: false };
+        }
+      }
+      return {
+        signIn,
+        signUp,
+        isSuccess: false
+      };
+    } catch (error) {
+      return {
+        signIn,
+        signUp,
+        error,
+        isSuccess: false
+      };
+    } finally {
+      setIsVerifying(false);
+    }
+  };
+  return {
+    sendOtpCode,
+    verifyCode,
+    isVerifying
+  };
+}
+
+// src/hooks/use-auth-with-identifier.ts
+import { isClerkAPIResponseError } from "@clerk/clerk-expo";
+import { useState as useState4 } from "react";
+function useAuthWithIdentifier(method, verifyBy) {
+  const { signUp, signIn, setActive } = useClerkResources();
+  const { sendOtpCode, verifyCode: verifyOtpCode, isVerifying } = useOtpVerification();
+  const { getSessionToken } = useGetSessionToken();
+  const [isAuthorizing, setIsAuthorizing] = useState4(false);
+  const [isLoading, setIsLoading] = useState4(false);
+  const strategy = method === "emailAddress" ? "email_code" : "phone_code";
+  const handleSessionToken = async (tokenTemplate) => {
+    const { sessionToken, error } = await getSessionToken({ tokenTemplate });
+    return { sessionToken: sessionToken || void 0, error };
+  };
+  const handleSignInWithPassword = async (signInAttempt, isSignUp, tokenTemplate) => {
+    await setActive?.({ session: signInAttempt.createdSessionId });
+    const { sessionToken, error } = await handleSessionToken(tokenTemplate);
+    if (isSignUp) {
+      return {
+        signUp,
+        error,
+        sessionToken,
+        isSuccess: !!sessionToken
+      };
+    }
+    return {
+      signIn,
+      error,
+      sessionToken,
+      isSuccess: !!sessionToken
+    };
+  };
+  const handleUsernameAuth = async (params, isSignUp) => {
+    const { identifier, password, tokenTemplate } = params;
+    const authMethod = isSignUp ? signUp : signIn;
+    const authAttempt = await authMethod?.create({ username: identifier, password });
+    if (authAttempt?.status === "complete" && "createdSessionId" in authAttempt) {
+      return handleSignInWithPassword(authAttempt, isSignUp, tokenTemplate);
+    }
+    return {
+      isSuccess: false,
+      [isSignUp ? "signUp" : "signIn"]: authMethod
+    };
+  };
+  const handleEmailPhoneAuth = async (params, isSignUp) => {
+    const { identifier } = params;
+    const authMethod = isSignUp ? signUp : signIn;
+    const identifierFieldName = isSignUp ? method : "identifier";
+    if (verifyBy === "password") {
+      try {
+        const { password, tokenTemplate } = params;
+        const authAttempt = await authMethod?.create({ [identifierFieldName]: identifier, password });
+        if (authAttempt?.status === "complete" && "createdSessionId" in authAttempt) {
+          return handleSignInWithPassword(authAttempt, isSignUp, tokenTemplate);
+        } else {
+          return { isSuccess: false, signIn, signUp, status: authAttempt?.status, error: null };
+        }
+      } catch (error) {
+        return { error, signIn, signUp };
+      }
+    } else if (verifyBy === "otp") {
+      try {
+        await authMethod?.create({ [identifierFieldName]: identifier });
+        await sendOtpCode({ strategy, isSignUp });
+      } catch (error) {
+        return { error, signIn, signUp };
+      }
+    }
+    return {
+      isSuccess: true,
+      [isSignUp ? "signUp" : "signIn"]: authMethod
+    };
+  };
+  const startSignUp = async (params) => {
+    try {
+      setIsLoading(true);
+      return method === "username" ? await handleUsernameAuth(params, true) : await handleEmailPhoneAuth(params, true);
+    } catch (error) {
+      return { error, signUp, isSuccess: false };
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const startSignIn = async (params) => {
+    try {
+      setIsLoading(true);
+      return method === "username" ? await handleUsernameAuth(params, false) : await handleEmailPhoneAuth(params, false);
+    } catch (error) {
+      return { error, signIn, isSuccess: false };
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const startAuthorization = async (params) => {
+    try {
+      setIsAuthorizing(true);
+      const result = await startSignUp(params);
+      if (result?.error && isClerkAPIResponseError(result.error)) {
+        const error = result.error.errors[0];
+        if (error?.code === "form_identifier_exists" /* FORM_IDENTIFIER_EXIST */) {
+          const signInResult = await startSignIn(params);
+          return { ...signInResult, isSignUp: false };
+        }
+      }
+      return { ...result, isSignUp: true };
+    } catch (error) {
+      return { error, signIn, signUp, isSuccess: false };
+    } finally {
+      setIsAuthorizing(false);
+    }
+  };
+  const verifyCode = async ({
+    code,
+    isSignUp,
+    tokenTemplate
+  }) => {
+    setIsLoading(true);
+    try {
+      return await verifyOtpCode({ code, strategy, tokenTemplate, isSignUp });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  if (method === "username") {
+    return {
+      startSignIn,
+      startSignUp,
+      startAuthorization,
+      isLoading: isAuthorizing || isLoading
+    };
+  } else {
+    return {
+      startSignIn,
+      startSignUp,
+      startAuthorization,
+      isLoading: isAuthorizing || isLoading,
+      verifyCode,
+      isVerifying
+    };
+  }
+}
+
+// src/hooks/use-add-identifier.ts
+import { isClerkAPIResponseError as isClerkAPIResponseError2, useUser } from "@clerk/clerk-expo";
+import { useState as useState5 } from "react";
+function useAddIdentifier(type) {
+  const { user } = useUser();
+  const [isCreating, setIsCreating] = useState5(false);
+  const [isVerifying, setIsVerifying] = useState5(false);
+  const isEmail = type === "email";
+  const createIdentifier = async ({ identifier }) => {
+    setIsCreating(true);
+    try {
+      let resource = getIdentifierResource(identifier);
+      if (!resource) {
+        resource = isEmail ? await user?.createEmailAddress({ email: identifier }) : await user?.createPhoneNumber({ phoneNumber: identifier });
+        await user?.reload();
+      }
+      await prepareVerification({ isEmail, identifier });
+      return { isSuccess: true, user };
+    } catch (e) {
+      if (isClerkAPIResponseError2(e)) {
+        return { error: e, user };
+      }
+      return { isSuccess: false, user };
+    } finally {
+      setIsCreating(false);
+    }
+  };
+  const verifyCode = async ({ code, identifier }) => {
+    setIsVerifying(true);
+    try {
+      const resource = getIdentifierResource(identifier);
+      const verifyAttempt = await resource?.attemptVerification({ code });
+      if (verifyAttempt?.verification?.status === "verified") {
+        return { isSuccess: true, user };
+      } else {
+        return { isSuccess: false, verifyAttempt };
+      }
+    } catch (error) {
+      return { error, user };
+    } finally {
+      setIsVerifying(false);
+    }
+  };
+  const prepareVerification = async ({
+    isEmail: isEmail2,
+    identifier
+  }) => {
+    const phoneResource = user?.phoneNumbers?.find((a) => a.phoneNumber === identifier);
+    const emailResource = user?.emailAddresses?.find((a) => a.emailAddress === identifier);
+    await (isEmail2 ? emailResource?.prepareVerification({ strategy: "email_code" }) : phoneResource?.prepareVerification());
+  };
+  const getIdentifierResource = (identifier) => {
+    return isEmail ? user?.emailAddresses.find((a) => a.emailAddress === identifier) : user?.phoneNumbers.find((a) => a.phoneNumber === identifier);
+  };
+  return { createIdentifier, verifyCode, isCreating, isVerifying };
+}
+
+// src/hooks/use-reset-password.ts
+import { useState as useState6 } from "react";
+function useResetPassword({ method }) {
+  const { signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isCodeSending, setIsCodeSending] = useState6(false);
+  const [isVerifying, setIsVerifying] = useState6(false);
+  const [isResetting, setIsResetting] = useState6(false);
+  const strategy = method === "emailAddress" ? "reset_password_email_code" : "reset_password_phone_code";
+  const startResetPassword = async ({ identifier }) => {
+    setIsCodeSending(true);
+    try {
+      await signIn?.create({
+        strategy,
+        identifier
+      });
+      return { isSuccess: true, signIn };
+    } catch (error) {
+      return { isSuccess: false, signIn, error };
+    } finally {
+      setIsCodeSending(false);
+    }
+  };
+  const verifyCode = async ({ code }) => {
+    setIsVerifying(true);
+    try {
+      await signIn?.attemptFirstFactor({
+        strategy,
+        code
+      });
+      return { isSuccess: true, signIn };
+    } catch (error) {
+      return { isSuccess: false, signIn, error };
+    } finally {
+      setIsVerifying(false);
+    }
+  };
+  const resetPassword = async ({ password, tokenTemplate }) => {
+    setIsResetting(true);
+    try {
+      const result = await signIn?.resetPassword({
+        password
+      });
+      await setActive({ session: result?.createdSessionId });
+      const { sessionToken, error } = await getSessionToken({ tokenTemplate });
+      if (sessionToken) {
+        return {
+          isSuccess: true,
+          signIn,
+          sessionToken
+        };
+      } else {
+        return {
+          signIn,
+          error,
+          isSuccess: false
+        };
+      }
+    } catch (error) {
+      return { isSuccess: false, signIn, error };
+    } finally {
+      setIsResetting(false);
+    }
+  };
+  return {
+    startResetPassword,
+    verifyCode,
+    resetPassword,
+    isCodeSending,
+    isVerifying,
+    isResetting
+  };
+}
+
+// src/hooks/use-update-password.ts
+import { useUser as useUser2 } from "@clerk/clerk-expo";
+import { useState as useState7 } from "react";
+var useChangePassword = () => {
+  const { user } = useUser2();
+  const [isPasswordUpdating, setIsPasswordUpdating] = useState7(false);
+  const updatePassword = async (params) => {
+    const { newPassword, currentPassword } = params;
+    try {
+      setIsPasswordUpdating(true);
+      await user?.updatePassword({ newPassword, currentPassword });
+      return { isSuccess: true };
+    } catch (error) {
+      return { isSuccess: false, error };
+    } finally {
+      setIsPasswordUpdating(false);
+    }
+  };
+  return { updatePassword, isPasswordUpdating };
+};
+
+// src/hooks/use-update-identifier.ts
+import { useUser as useUser3 } from "@clerk/clerk-expo";
+import { useState as useState8 } from "react";
+function useUpdateIdentifier(type) {
+  const { user } = useUser3();
+  const isEmail = type === "email";
+  const { createIdentifier, verifyCode: verifyAddIdentifierCode, isCreating, isVerifying } = useAddIdentifier(type);
+  const [isUpdating, setIsUpdating] = useState8(false);
+  const getIdentifierResource = (identifier) => {
+    return isEmail ? user?.emailAddresses?.find((a) => a.emailAddress === identifier) : user?.phoneNumbers?.find((a) => a.phoneNumber === identifier);
+  };
+  const swapPrimaryIdentifier = async (identifier) => {
+    const newResource = getIdentifierResource(identifier);
+    if (!newResource || newResource.verification?.status !== "verified") {
+      throw new Error("Identifier not found or not verified");
+    }
+    const currentPrimaryId = isEmail ? user?.primaryEmailAddressId : user?.primaryPhoneNumberId;
+    const resources = isEmail ? user?.emailAddresses : user?.phoneNumbers;
+    const oldPrimaryResource = resources?.find((r) => r.id === currentPrimaryId);
+    if (isEmail) {
+      await user?.update({ primaryEmailAddressId: newResource.id });
+    } else {
+      await user?.update({ primaryPhoneNumberId: newResource.id });
+    }
+    if (oldPrimaryResource && oldPrimaryResource.id !== newResource.id) {
+      await oldPrimaryResource.destroy();
+    }
+    await user?.reload();
+  };
+  const verifyCode = async ({ code, identifier }) => {
+    setIsUpdating(true);
+    const result = await verifyAddIdentifierCode({ code, identifier });
+    await user?.reload();
+    if (!result.isSuccess) {
+      setIsUpdating(false);
+      return result;
+    }
+    try {
+      await swapPrimaryIdentifier(identifier);
+      return { isSuccess: true, user };
+    } catch (error) {
+      return { isSuccess: false, error, user };
+    } finally {
+      setIsUpdating(false);
+    }
+  };
+  return {
+    createIdentifier,
+    verifyCode,
+    isCreating,
+    isVerifying,
+    isUpdating
+  };
+}
+export {
+  ClerkApiError,
+  useAddIdentifier,
+  useAuthWithIdentifier,
+  useAuthWithSSO,
+  useAuthWithTicket,
+  useChangePassword,
+  useClerkResources,
+  useGetSessionToken,
+  useOtpVerification,
+  useResetPassword,
+  useUpdateIdentifier
+};
+//# sourceMappingURL=index.mjs.map