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

package/dist/index.js

@@ -0,0 +1,648 @@
+"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, {
+  ClerkApiError: () => ClerkApiError,
+  useAddIdentifier: () => useAddIdentifier,
+  useAuthWithIdentifier: () => useAuthWithIdentifier,
+  useAuthWithSSO: () => useAuthWithSSO,
+  useAuthWithTicket: () => useAuthWithTicket,
+  useChangePassword: () => useChangePassword,
+  useClerkResources: () => useClerkResources,
+  useGetSessionToken: () => useGetSessionToken,
+  useOtpVerification: () => useOtpVerification,
+  useResetPassword: () => useResetPassword,
+  useUpdateIdentifier: () => useUpdateIdentifier
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_clerk_expo = require("@clerk/clerk-expo");
+var useClerkResources = () => {
+  const clerk = (0, import_clerk_expo.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
+var import_clerk_expo2 = require("@clerk/clerk-expo");
+var useGetSessionToken = () => {
+  const clerk = (0, import_clerk_expo2.getClerkInstance)();
+  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
+var import_clerk_expo3 = require("@clerk/clerk-expo");
+var import_react = require("react");
+function useAuthWithSSO() {
+  const { startSSOFlow: clerkStartSSOFlow } = (0, import_clerk_expo3.useSSO)();
+  const { getSessionToken } = useGetSessionToken();
+  const [isLoading, setIsLoading] = (0, import_react.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
+var import_react2 = require("react");
+function useAuthWithTicket() {
+  const { signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(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
+var import_react3 = require("react");
+function useOtpVerification() {
+  const { signUp, signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isVerifying, setIsVerifying] = (0, import_react3.useState)(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
+var import_clerk_expo4 = require("@clerk/clerk-expo");
+var import_react4 = require("react");
+function useAuthWithIdentifier(method, verifyBy) {
+  const { signUp, signIn, setActive } = useClerkResources();
+  const { sendOtpCode, verifyCode: verifyOtpCode, isVerifying } = useOtpVerification();
+  const { getSessionToken } = useGetSessionToken();
+  const [isAuthorizing, setIsAuthorizing] = (0, import_react4.useState)(false);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(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 && (0, import_clerk_expo4.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
+var import_clerk_expo5 = require("@clerk/clerk-expo");
+var import_react5 = require("react");
+function useAddIdentifier(type) {
+  const { user } = (0, import_clerk_expo5.useUser)();
+  const [isCreating, setIsCreating] = (0, import_react5.useState)(false);
+  const [isVerifying, setIsVerifying] = (0, import_react5.useState)(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 ((0, import_clerk_expo5.isClerkAPIResponseError)(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
+var import_react6 = require("react");
+function useResetPassword({ method }) {
+  const { signIn, setActive } = useClerkResources();
+  const { getSessionToken } = useGetSessionToken();
+  const [isCodeSending, setIsCodeSending] = (0, import_react6.useState)(false);
+  const [isVerifying, setIsVerifying] = (0, import_react6.useState)(false);
+  const [isResetting, setIsResetting] = (0, import_react6.useState)(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
+var import_clerk_expo6 = require("@clerk/clerk-expo");
+var import_react7 = require("react");
+var useChangePassword = () => {
+  const { user } = (0, import_clerk_expo6.useUser)();
+  const [isPasswordUpdating, setIsPasswordUpdating] = (0, import_react7.useState)(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
+var import_clerk_expo7 = require("@clerk/clerk-expo");
+var import_react8 = require("react");
+function useUpdateIdentifier(type) {
+  const { user } = (0, import_clerk_expo7.useUser)();
+  const isEmail = type === "email";
+  const { createIdentifier, verifyCode: verifyAddIdentifierCode, isCreating, isVerifying } = useAddIdentifier(type);
+  const [isUpdating, setIsUpdating] = (0, import_react8.useState)(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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClerkApiError,
+  useAddIdentifier,
+  useAuthWithIdentifier,
+  useAuthWithSSO,
+  useAuthWithTicket,
+  useChangePassword,
+  useClerkResources,
+  useGetSessionToken,
+  useOtpVerification,
+  useResetPassword,
+  useUpdateIdentifier
+});
+//# sourceMappingURL=index.js.map