@dloizides/auth-web 1.2.0

package/dist/index.mjs

@@ -0,0 +1,1373 @@
+import { createContext, useState, useRef, useEffect, useCallback, useMemo, useContext } from 'react';
+import { View, Text, TextInput, TouchableOpacity, ActivityIndicator, StyleSheet } from 'react-native';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useMutation } from '@tanstack/react-query';
+import { BffAuthClient, createFetchHttpClient } from '@dloizides/auth-client';
+export { BffAuthClient, createFetchHttpClient } from '@dloizides/auth-client';
+
+// src/components/LoginForm.tsx
+
+// src/components/labels.ts
+var DEFAULT_LOGIN_LABELS = {
+  title: "Sign in",
+  subtitle: "Welcome back",
+  usernameLabel: "Username",
+  usernamePlaceholder: "Enter your username",
+  passwordLabel: "Password",
+  passwordPlaceholder: "Enter your password",
+  submit: "Sign in",
+  submitting: "Signing in...",
+  forgotPassword: "Forgot password?",
+  invalidCredentials: "Incorrect username or password.",
+  missingFields: "Enter both your username and password."
+};
+var DEFAULT_FORGOT_PASSWORD_LABELS = {
+  title: "Forgot password",
+  description: "Enter your email and we will send you a reset link.",
+  emailLabel: "Email",
+  emailPlaceholder: "Enter your email",
+  submit: "Send reset link",
+  submitting: "Sending...",
+  successMessage: "If that email is registered, a reset link is on its way.",
+  networkError: "Something went wrong. Please try again.",
+  invalidEmail: "Enter a valid email address."
+};
+var DEFAULT_OTP_LABELS = {
+  requestTitle: "Sign in with a code",
+  requestDescription: "Enter your email and we will send you a one-time code.",
+  emailLabel: "Email",
+  emailPlaceholder: "Enter your email",
+  requestSubmit: "Send code",
+  requesting: "Sending...",
+  invalidEmail: "Enter a valid email address.",
+  verifyTitle: "Enter your code",
+  verifyDescription: "We sent a one-time code to {identifier}.",
+  codeLabel: "One-time code",
+  codePlaceholder: "Enter the code",
+  verifySubmit: "Verify",
+  verifying: "Verifying...",
+  missingCode: "Enter the code we emailed you.",
+  invalidCode: "That code is incorrect or has expired.",
+  resend: "Resend code",
+  resending: "Resending...",
+  changeEmail: "Use a different email"
+};
+var DEFAULT_PIN_LABELS = {
+  title: "Enter your event PIN",
+  description: "Enter the PIN for this event to sign in.",
+  pinLabel: "PIN",
+  pinPlaceholder: "Enter your PIN",
+  submit: "Sign in",
+  submitting: "Signing in...",
+  missingPin: "Enter your event PIN.",
+  invalidPin: "That PIN is incorrect, has expired, or is locked out."
+};
+var DEFAULT_RESET_PASSWORD_LABELS = {
+  title: "Reset password",
+  description: "Choose a new password for your account.",
+  newPasswordLabel: "New password",
+  newPasswordPlaceholder: "Enter a new password",
+  confirmPasswordLabel: "Confirm password",
+  confirmPasswordPlaceholder: "Re-enter the new password",
+  submit: "Reset password",
+  submitting: "Resetting...",
+  errorEmpty: "Fill in both password fields.",
+  errorWeakPassword: "Use at least 8 characters with an uppercase letter, a lowercase letter and a digit.",
+  errorMismatch: "The passwords do not match.",
+  errorTokenInvalid: "This reset link is invalid or has expired. Request a new one.",
+  errorNetwork: "Something went wrong. Please try again."
+};
+
+// src/components/testIds.ts
+var AuthTestIds = {
+  loginForm: "auth-login-form",
+  loginUsernameInput: "auth-login-username",
+  loginPasswordInput: "auth-login-password",
+  loginSubmitButton: "auth-login-submit",
+  loginForgotLink: "auth-login-forgot-link",
+  loginError: "auth-login-error",
+  forgotPasswordForm: "auth-forgot-form",
+  forgotPasswordEmailInput: "auth-forgot-email",
+  forgotPasswordSubmitButton: "auth-forgot-submit",
+  forgotPasswordError: "auth-forgot-error",
+  forgotPasswordSuccess: "auth-forgot-success",
+  resetPasswordForm: "auth-reset-form",
+  resetPasswordNewInput: "auth-reset-new",
+  resetPasswordConfirmInput: "auth-reset-confirm",
+  resetPasswordSubmitButton: "auth-reset-submit",
+  resetPasswordError: "auth-reset-error",
+  otpForm: "auth-otp-form",
+  otpEmailInput: "auth-otp-email",
+  otpRequestButton: "auth-otp-request",
+  otpCodeInput: "auth-otp-code",
+  otpVerifyButton: "auth-otp-verify",
+  otpResendButton: "auth-otp-resend",
+  otpChangeEmailButton: "auth-otp-change-email",
+  otpError: "auth-otp-error",
+  pinForm: "auth-pin-form",
+  pinInput: "auth-pin-input",
+  pinSubmitButton: "auth-pin-submit",
+  pinError: "auth-pin-error"
+};
+function withTestIdPrefix(baseId, prefix) {
+  return prefix === void 0 || prefix === "" ? baseId : `${prefix}-${baseId}`;
+}
+var FULL_WIDTH = "100%";
+var CARD_MAX_WIDTH = 420;
+var BUTTON_VERTICAL_PADDING = 14;
+function useAuthStyles(theme) {
+  return useMemo(() => {
+    const { colors, radii, spacing, typography } = theme;
+    return StyleSheet.create({
+      screen: {
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+        padding: spacing.md,
+        backgroundColor: colors.background
+      },
+      card: {
+        width: FULL_WIDTH,
+        maxWidth: CARD_MAX_WIDTH,
+        borderRadius: radii.card,
+        padding: spacing.xl,
+        backgroundColor: colors.surface
+      },
+      title: {
+        fontSize: typography.title,
+        fontWeight: "bold",
+        textAlign: "center",
+        marginBottom: spacing.xs,
+        color: colors.text
+      },
+      subtitle: {
+        fontSize: typography.subtitle,
+        textAlign: "center",
+        marginBottom: spacing.lg,
+        color: colors.textSecondary
+      },
+      fieldGroup: {
+        marginBottom: spacing.md
+      },
+      label: {
+        fontSize: typography.label,
+        fontWeight: "600",
+        marginBottom: spacing.xs,
+        color: colors.text
+      },
+      input: {
+        borderWidth: 1,
+        borderRadius: radii.input,
+        padding: spacing.sm,
+        fontSize: typography.body,
+        borderColor: colors.border,
+        backgroundColor: colors.background,
+        color: colors.text
+      },
+      inputError: {
+        borderColor: colors.danger
+      },
+      primaryButton: {
+        borderRadius: radii.input,
+        paddingVertical: BUTTON_VERTICAL_PADDING,
+        alignItems: "center",
+        justifyContent: "center",
+        marginTop: spacing.xs,
+        backgroundColor: colors.primary
+      },
+      primaryButtonDisabled: {
+        backgroundColor: colors.border
+      },
+      primaryButtonText: {
+        fontSize: typography.body,
+        fontWeight: "600",
+        color: colors.onPrimary
+      },
+      linkText: {
+        fontSize: typography.caption,
+        textDecorationLine: "underline",
+        color: colors.primary
+      },
+      errorText: {
+        fontSize: typography.caption,
+        marginTop: spacing.xs,
+        color: colors.danger
+      },
+      successText: {
+        fontSize: typography.body,
+        lineHeight: typography.body * 1.4,
+        color: colors.success
+      },
+      helperText: {
+        fontSize: typography.caption,
+        color: colors.textSecondary
+      }
+    });
+  }, [theme]);
+}
+var BffAuthStatus = /* @__PURE__ */ ((BffAuthStatus2) => {
+  BffAuthStatus2["Loading"] = "loading";
+  BffAuthStatus2["Authenticated"] = "authenticated";
+  BffAuthStatus2["Unauthenticated"] = "unauthenticated";
+  return BffAuthStatus2;
+})(BffAuthStatus || {});
+var INITIAL_LOADING = { user: null, status: "loading" /* Loading */ };
+var INITIAL_IDLE = { user: null, status: "unauthenticated" /* Unauthenticated */ };
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function useBffAuth(options) {
+  const { client, probeOnMount = true } = options;
+  const [session, setSession] = useState(
+    probeOnMount ? INITIAL_LOADING : INITIAL_IDLE
+  );
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetSession = useCallback((next) => {
+    if (mountedRef.current) {
+      setSession(next);
+    }
+  }, []);
+  const refresh = useCallback(async () => {
+    try {
+      const user = await client.getCurrentUser();
+      safeSetSession(
+        user === null ? INITIAL_IDLE : { user, status: "authenticated" /* Authenticated */ }
+      );
+    } catch (caught) {
+      safeSetSession(INITIAL_IDLE);
+      if (mountedRef.current) {
+        setError(toError(caught));
+      }
+    }
+  }, [client, safeSetSession]);
+  const login = useCallback(
+    async (request) => {
+      if (mountedRef.current) {
+        setIsSubmitting(true);
+        setError(null);
+      }
+      try {
+        const user = await client.login(request);
+        safeSetSession({ user, status: "authenticated" /* Authenticated */ });
+        return user;
+      } catch (caught) {
+        const err = toError(caught);
+        if (mountedRef.current) {
+          setError(err);
+        }
+        throw err;
+      } finally {
+        if (mountedRef.current) {
+          setIsSubmitting(false);
+        }
+      }
+    },
+    [client, safeSetSession]
+  );
+  const logout = useCallback(async () => {
+    if (mountedRef.current) {
+      setIsSubmitting(true);
+      setError(null);
+    }
+    try {
+      await client.logout();
+    } catch (caught) {
+      if (mountedRef.current) {
+        setError(toError(caught));
+      }
+    } finally {
+      safeSetSession(INITIAL_IDLE);
+      if (mountedRef.current) {
+        setIsSubmitting(false);
+      }
+    }
+  }, [client, safeSetSession]);
+  useEffect(() => {
+    if (probeOnMount) {
+      void refresh();
+    }
+  }, [probeOnMount, refresh]);
+  return useMemo(
+    () => ({
+      user: session.user,
+      status: session.status,
+      isSubmitting,
+      error,
+      login,
+      logout,
+      refresh
+    }),
+    [session.user, session.status, isSubmitting, error, login, logout, refresh]
+  );
+}
+
+// src/theme/AuthTheme.ts
+var defaultAuthTheme = {
+  colors: {
+    background: "#f5f5f7",
+    surface: "#ffffff",
+    text: "#1a1a1a",
+    textSecondary: "#6b6b6b",
+    border: "#d0d0d5",
+    primary: "#2563eb",
+    onPrimary: "#ffffff",
+    danger: "#d33333",
+    success: "#1f7a3d"
+  },
+  radii: {
+    input: 8,
+    card: 12
+  },
+  spacing: {
+    xs: 8,
+    sm: 12,
+    md: 20,
+    lg: 32,
+    xl: 24
+  },
+  typography: {
+    title: 28,
+    subtitle: 16,
+    label: 14,
+    body: 16,
+    caption: 12
+  }
+};
+var AuthThemeContext = createContext(defaultAuthTheme);
+function AuthThemeProvider({
+  theme,
+  children
+}) {
+  return /* @__PURE__ */ jsx(AuthThemeContext.Provider, { value: theme, children });
+}
+function useAuthTheme(themeProp) {
+  const contextTheme = useContext(AuthThemeContext);
+  return useMemo(() => themeProp ?? contextTheme, [themeProp, contextTheme]);
+}
+function LoginForm({
+  client,
+  theme: themeProp,
+  labels: labelsProp,
+  onSuccess,
+  onForgotPassword,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_LOGIN_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const { login, isSubmitting } = useBffAuth({ client, probeOnMount: false });
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [errorText, setErrorText] = useState(null);
+  const runLogin = useCallback(async () => {
+    setErrorText(null);
+    const trimmedUsername = username.trim();
+    const hasMissingField = trimmedUsername.length === 0 || password.length === 0;
+    if (hasMissingField) {
+      setErrorText(labels.missingFields);
+      return;
+    }
+    try {
+      const user = await login({ username: trimmedUsername, password });
+      onSuccess(user);
+    } catch {
+      setErrorText(labels.invalidCredentials);
+    }
+  }, [username, password, login, onSuccess, labels.missingFields, labels.invalidCredentials]);
+  const handleSubmit = useCallback(() => {
+    void runLogin();
+  }, [runLogin]);
+  const submitButtonStyle = isSubmitting ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  return /* @__PURE__ */ jsx(View, { style: styles.screen, children: /* @__PURE__ */ jsxs(View, { style: styles.card, testID: withTestIdPrefix(AuthTestIds.loginForm, testIdPrefix), children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.title }),
+    /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: labels.subtitle }),
+    /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.usernameLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          accessibilityHint: labels.usernamePlaceholder,
+          accessibilityLabel: labels.usernameLabel,
+          autoCapitalize: "none",
+          autoCorrect: false,
+          editable: !isSubmitting,
+          placeholder: labels.usernamePlaceholder,
+          placeholderTextColor: theme.colors.textSecondary,
+          style: styles.input,
+          testID: withTestIdPrefix(AuthTestIds.loginUsernameInput, testIdPrefix),
+          value: username,
+          onChangeText: setUsername
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.passwordLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          secureTextEntry: true,
+          accessibilityHint: labels.passwordPlaceholder,
+          accessibilityLabel: labels.passwordLabel,
+          autoCapitalize: "none",
+          autoCorrect: false,
+          editable: !isSubmitting,
+          placeholder: labels.passwordPlaceholder,
+          placeholderTextColor: theme.colors.textSecondary,
+          style: styles.input,
+          testID: withTestIdPrefix(AuthTestIds.loginPasswordInput, testIdPrefix),
+          value: password,
+          onChangeText: setPassword
+        }
+      )
+    ] }),
+    errorText !== null ? /* @__PURE__ */ jsx(
+      Text,
+      {
+        style: styles.errorText,
+        testID: withTestIdPrefix(AuthTestIds.loginError, testIdPrefix),
+        children: errorText
+      }
+    ) : null,
+    onForgotPassword !== void 0 ? /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.forgotPassword,
+        accessibilityLabel: labels.forgotPassword,
+        accessibilityRole: "link",
+        disabled: isSubmitting,
+        style: styles.fieldGroup,
+        testID: withTestIdPrefix(AuthTestIds.loginForgotLink, testIdPrefix),
+        onPress: onForgotPassword,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.linkText, children: labels.forgotPassword })
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.submit,
+        accessibilityLabel: isSubmitting ? labels.submitting : labels.submit,
+        accessibilityRole: "button",
+        disabled: isSubmitting,
+        style: submitButtonStyle,
+        testID: withTestIdPrefix(AuthTestIds.loginSubmitButton, testIdPrefix),
+        onPress: handleSubmit,
+        children: isSubmitting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.submit })
+      }
+    )
+  ] }) });
+}
+function useBffForgotPassword(options) {
+  const { client, ...rest } = options;
+  return useMutation({
+    mutationFn: async (request) => {
+      await client.forgotPassword(request);
+      return void 0;
+    },
+    ...rest
+  });
+}
+function useBffResetPassword(options) {
+  const { client, ...rest } = options;
+  return useMutation({
+    mutationFn: async (request) => {
+      await client.resetPassword(request);
+      return void 0;
+    },
+    ...rest
+  });
+}
+var EMAIL_REGEX = /^[^@\s]+@[^.\s]+\.[^\s]+$/;
+function isValidEmail(value) {
+  return EMAIL_REGEX.test(value);
+}
+function ForgotPasswordForm({
+  client,
+  theme: themeProp,
+  labels: labelsProp,
+  resetUrlTemplate,
+  onSuccess,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_FORGOT_PASSWORD_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const [email, setEmail] = useState("");
+  const [submitted, setSubmitted] = useState(false);
+  const [errorText, setErrorText] = useState(null);
+  const mutationOptions = useMemo(
+    () => ({
+      client,
+      onSuccess: () => {
+        setSubmitted(true);
+        onSuccess?.();
+      },
+      onError: () => {
+        setErrorText(labels.networkError);
+      }
+    }),
+    [client, onSuccess, labels.networkError]
+  );
+  const mutation = useBffForgotPassword(mutationOptions);
+  const isPending = mutation.status === "pending";
+  const handleSubmit = useCallback(() => {
+    setErrorText(null);
+    const trimmedEmail = email.trim();
+    if (!isValidEmail(trimmedEmail)) {
+      setErrorText(labels.invalidEmail);
+      return;
+    }
+    mutation.mutate({ email: trimmedEmail, resetUrlTemplate });
+  }, [email, mutation, resetUrlTemplate, labels.invalidEmail]);
+  const submitButtonStyle = isPending ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  return /* @__PURE__ */ jsx(View, { style: styles.screen, children: /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: styles.card,
+      testID: withTestIdPrefix(AuthTestIds.forgotPasswordForm, testIdPrefix),
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.title }),
+        submitted ? /* @__PURE__ */ jsx(
+          Text,
+          {
+            style: styles.successText,
+            testID: withTestIdPrefix(AuthTestIds.forgotPasswordSuccess, testIdPrefix),
+            children: labels.successMessage
+          }
+        ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: labels.description }),
+          /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+            /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.emailLabel }),
+            /* @__PURE__ */ jsx(
+              TextInput,
+              {
+                accessibilityHint: labels.emailPlaceholder,
+                accessibilityLabel: labels.emailLabel,
+                autoCapitalize: "none",
+                autoCorrect: false,
+                editable: !isPending,
+                keyboardType: "email-address",
+                placeholder: labels.emailPlaceholder,
+                placeholderTextColor: theme.colors.textSecondary,
+                style: styles.input,
+                testID: withTestIdPrefix(AuthTestIds.forgotPasswordEmailInput, testIdPrefix),
+                value: email,
+                onChangeText: setEmail
+              }
+            )
+          ] }),
+          errorText !== null ? /* @__PURE__ */ jsx(
+            Text,
+            {
+              style: styles.errorText,
+              testID: withTestIdPrefix(AuthTestIds.forgotPasswordError, testIdPrefix),
+              children: errorText
+            }
+          ) : null,
+          /* @__PURE__ */ jsx(
+            TouchableOpacity,
+            {
+              accessibilityHint: labels.submit,
+              accessibilityLabel: isPending ? labels.submitting : labels.submit,
+              accessibilityRole: "button",
+              disabled: isPending,
+              style: submitButtonStyle,
+              testID: withTestIdPrefix(AuthTestIds.forgotPasswordSubmitButton, testIdPrefix),
+              onPress: handleSubmit,
+              children: isPending ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.submit })
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/hooks/ResetPasswordError.ts
+var ResetPasswordError = /* @__PURE__ */ ((ResetPasswordError2) => {
+  ResetPasswordError2["Empty"] = "empty";
+  ResetPasswordError2["WeakPassword"] = "weakPassword";
+  ResetPasswordError2["Mismatch"] = "mismatch";
+  ResetPasswordError2["TokenInvalid"] = "tokenInvalid";
+  ResetPasswordError2["Network"] = "network";
+  return ResetPasswordError2;
+})(ResetPasswordError || {});
+
+// src/password/PasswordPolicyError.ts
+var PasswordPolicyError = /* @__PURE__ */ ((PasswordPolicyError2) => {
+  PasswordPolicyError2["TooShort"] = "tooShort";
+  PasswordPolicyError2["TooLong"] = "tooLong";
+  PasswordPolicyError2["MissingUppercase"] = "missingUppercase";
+  PasswordPolicyError2["MissingLowercase"] = "missingLowercase";
+  PasswordPolicyError2["MissingDigit"] = "missingDigit";
+  return PasswordPolicyError2;
+})(PasswordPolicyError || {});
+
+// src/password/passwordPolicy.ts
+var UPPERCASE_REGEX = /[A-Z]/;
+var LOWERCASE_REGEX = /[a-z]/;
+var DIGIT_REGEX = /\d/;
+var PASSWORD_MIN_LENGTH = 8;
+var PASSWORD_MAX_LENGTH = 128;
+function validatePasswordPolicy(password) {
+  const errors = [];
+  if (password.length < PASSWORD_MIN_LENGTH) {
+    errors.push("tooShort" /* TooShort */);
+  }
+  if (password.length > PASSWORD_MAX_LENGTH) {
+    errors.push("tooLong" /* TooLong */);
+  }
+  if (!UPPERCASE_REGEX.test(password)) {
+    errors.push("missingUppercase" /* MissingUppercase */);
+  }
+  if (!LOWERCASE_REGEX.test(password)) {
+    errors.push("missingLowercase" /* MissingLowercase */);
+  }
+  if (!DIGIT_REGEX.test(password)) {
+    errors.push("missingDigit" /* MissingDigit */);
+  }
+  return errors;
+}
+function isPasswordValid(password) {
+  return validatePasswordPolicy(password).length === 0;
+}
+
+// src/hooks/useResetPasswordForm.ts
+var HTTP_BAD_REQUEST = 400;
+function isHttpStatusError(message, status) {
+  return message.includes(` status ${String(status)}`);
+}
+function preflight(args) {
+  if (args.newPassword.length === 0 || args.confirm.length === 0) {
+    return "empty" /* Empty */;
+  }
+  if (!isPasswordValid(args.newPassword)) {
+    return "weakPassword" /* WeakPassword */;
+  }
+  if (args.newPassword !== args.confirm) {
+    return "mismatch" /* Mismatch */;
+  }
+  if (args.token === "") {
+    return "tokenInvalid" /* TokenInvalid */;
+  }
+  return null;
+}
+function useResetMutation(client, callbacks) {
+  const mutationOptions = useMemo(
+    () => ({
+      client,
+      onSuccess: callbacks.onSuccess,
+      onError: (err) => {
+        if (isHttpStatusError(err.message, HTTP_BAD_REQUEST)) {
+          callbacks.setHasInvalidToken(true);
+          callbacks.setErrorKey("tokenInvalid" /* TokenInvalid */);
+          return;
+        }
+        callbacks.setErrorKey("network" /* Network */);
+      }
+    }),
+    [client, callbacks]
+  );
+  return useBffResetPassword(mutationOptions);
+}
+function runSubmit(args) {
+  args.setErrorKey(null);
+  const failure = preflight({
+    newPassword: args.newPassword,
+    confirm: args.confirmPassword,
+    token: args.token
+  });
+  if (failure === null) {
+    args.mutate({ token: args.token, newPassword: args.newPassword });
+    return;
+  }
+  if (failure === "tokenInvalid" /* TokenInvalid */) {
+    args.setHasInvalidToken(true);
+  }
+  args.setErrorKey(failure);
+}
+function useFormState() {
+  const [newPassword, setNewPassword] = useState("");
+  const [confirmPassword, setConfirmPassword] = useState("");
+  const [errorKey, setErrorKey] = useState(null);
+  const [hasInvalidToken, setHasInvalidToken] = useState(false);
+  return {
+    state: { newPassword, confirmPassword, errorKey, hasInvalidToken },
+    setters: { setNewPassword, setConfirmPassword, setErrorKey, setHasInvalidToken }
+  };
+}
+function useResetPasswordForm({
+  client,
+  token,
+  onSuccess
+}) {
+  const { state, setters } = useFormState();
+  const callbacks = useMemo(
+    () => ({
+      onSuccess,
+      setErrorKey: setters.setErrorKey,
+      setHasInvalidToken: setters.setHasInvalidToken
+    }),
+    [onSuccess, setters.setErrorKey, setters.setHasInvalidToken]
+  );
+  const mutation = useResetMutation(client, callbacks);
+  const submit = () => runSubmit({
+    newPassword: state.newPassword,
+    confirmPassword: state.confirmPassword,
+    token,
+    setErrorKey: setters.setErrorKey,
+    setHasInvalidToken: setters.setHasInvalidToken,
+    mutate: mutation.mutate
+  });
+  return {
+    newPassword: state.newPassword,
+    confirmPassword: state.confirmPassword,
+    setNewPassword: setters.setNewPassword,
+    setConfirmPassword: setters.setConfirmPassword,
+    isSubmitting: mutation.status === "pending",
+    errorKey: state.errorKey,
+    hasInvalidToken: state.hasInvalidToken,
+    submit
+  };
+}
+function errorMessage(errorKey, labels) {
+  switch (errorKey) {
+    case "empty" /* Empty */:
+      return labels.errorEmpty;
+    case "weakPassword" /* WeakPassword */:
+      return labels.errorWeakPassword;
+    case "mismatch" /* Mismatch */:
+      return labels.errorMismatch;
+    case "tokenInvalid" /* TokenInvalid */:
+      return labels.errorTokenInvalid;
+    case "network" /* Network */:
+      return labels.errorNetwork;
+    default:
+      return null;
+  }
+}
+function ResetPasswordForm({
+  client,
+  token,
+  theme: themeProp,
+  labels: labelsProp,
+  onSuccess,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_RESET_PASSWORD_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const form = useResetPasswordForm({ client, token, onSuccess });
+  const message = errorMessage(form.errorKey, labels);
+  const submitButtonStyle = form.isSubmitting ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  return /* @__PURE__ */ jsx(View, { style: styles.screen, children: /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: styles.card,
+      testID: withTestIdPrefix(AuthTestIds.resetPasswordForm, testIdPrefix),
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.title }),
+        /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: labels.description }),
+        /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+          /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.newPasswordLabel }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              secureTextEntry: true,
+              accessibilityHint: labels.newPasswordPlaceholder,
+              accessibilityLabel: labels.newPasswordLabel,
+              autoCapitalize: "none",
+              autoCorrect: false,
+              editable: !form.isSubmitting,
+              placeholder: labels.newPasswordPlaceholder,
+              placeholderTextColor: theme.colors.textSecondary,
+              style: styles.input,
+              testID: withTestIdPrefix(AuthTestIds.resetPasswordNewInput, testIdPrefix),
+              value: form.newPassword,
+              onChangeText: form.setNewPassword
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+          /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.confirmPasswordLabel }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              secureTextEntry: true,
+              accessibilityHint: labels.confirmPasswordPlaceholder,
+              accessibilityLabel: labels.confirmPasswordLabel,
+              autoCapitalize: "none",
+              autoCorrect: false,
+              editable: !form.isSubmitting,
+              placeholder: labels.confirmPasswordPlaceholder,
+              placeholderTextColor: theme.colors.textSecondary,
+              style: styles.input,
+              testID: withTestIdPrefix(AuthTestIds.resetPasswordConfirmInput, testIdPrefix),
+              value: form.confirmPassword,
+              onChangeText: form.setConfirmPassword
+            }
+          )
+        ] }),
+        message !== null ? /* @__PURE__ */ jsx(
+          Text,
+          {
+            style: styles.errorText,
+            testID: withTestIdPrefix(AuthTestIds.resetPasswordError, testIdPrefix),
+            children: message
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          TouchableOpacity,
+          {
+            accessibilityHint: labels.submit,
+            accessibilityLabel: form.isSubmitting ? labels.submitting : labels.submit,
+            accessibilityRole: "button",
+            disabled: form.isSubmitting,
+            style: submitButtonStyle,
+            testID: withTestIdPrefix(AuthTestIds.resetPasswordSubmitButton, testIdPrefix),
+            onPress: form.submit,
+            children: form.isSubmitting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.submit })
+          }
+        )
+      ]
+    }
+  ) });
+}
+function OtpRequestStep({
+  styles,
+  theme,
+  labels,
+  testIdPrefix,
+  isSubmitting,
+  errorText,
+  onSubmit
+}) {
+  const [email, setEmail] = useState("");
+  const buttonStyle = isSubmitting ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.requestTitle }),
+    /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: labels.requestDescription }),
+    /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.emailLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          accessibilityHint: labels.emailPlaceholder,
+          accessibilityLabel: labels.emailLabel,
+          autoCapitalize: "none",
+          autoCorrect: false,
+          editable: !isSubmitting,
+          keyboardType: "email-address",
+          placeholder: labels.emailPlaceholder,
+          placeholderTextColor: theme.colors.textSecondary,
+          style: styles.input,
+          testID: withTestIdPrefix(AuthTestIds.otpEmailInput, testIdPrefix),
+          value: email,
+          onChangeText: setEmail
+        }
+      )
+    ] }),
+    errorText !== null ? /* @__PURE__ */ jsx(Text, { style: styles.errorText, testID: withTestIdPrefix(AuthTestIds.otpError, testIdPrefix), children: errorText }) : null,
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.requestSubmit,
+        accessibilityLabel: isSubmitting ? labels.requesting : labels.requestSubmit,
+        accessibilityRole: "button",
+        disabled: isSubmitting,
+        style: buttonStyle,
+        testID: withTestIdPrefix(AuthTestIds.otpRequestButton, testIdPrefix),
+        onPress: () => onSubmit(email.trim()),
+        children: isSubmitting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.requestSubmit })
+      }
+    )
+  ] });
+}
+function OtpVerifyStep({
+  styles,
+  theme,
+  labels,
+  testIdPrefix,
+  identifier,
+  isSubmitting,
+  errorText,
+  onSubmit,
+  onResend,
+  onChangeEmail
+}) {
+  const [code, setCode] = useState("");
+  const buttonStyle = isSubmitting ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  const description = labels.verifyDescription.replace("{identifier}", identifier);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.verifyTitle }),
+    /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: description }),
+    /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.codeLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          accessibilityHint: labels.codePlaceholder,
+          accessibilityLabel: labels.codeLabel,
+          autoCapitalize: "none",
+          autoCorrect: false,
+          editable: !isSubmitting,
+          keyboardType: "number-pad",
+          placeholder: labels.codePlaceholder,
+          placeholderTextColor: theme.colors.textSecondary,
+          style: styles.input,
+          testID: withTestIdPrefix(AuthTestIds.otpCodeInput, testIdPrefix),
+          value: code,
+          onChangeText: setCode
+        }
+      )
+    ] }),
+    errorText !== null ? /* @__PURE__ */ jsx(Text, { style: styles.errorText, testID: withTestIdPrefix(AuthTestIds.otpError, testIdPrefix), children: errorText }) : null,
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.verifySubmit,
+        accessibilityLabel: isSubmitting ? labels.verifying : labels.verifySubmit,
+        accessibilityRole: "button",
+        disabled: isSubmitting,
+        style: buttonStyle,
+        testID: withTestIdPrefix(AuthTestIds.otpVerifyButton, testIdPrefix),
+        onPress: () => onSubmit(code.trim()),
+        children: isSubmitting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.verifySubmit })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.resend,
+        accessibilityLabel: isSubmitting ? labels.resending : labels.resend,
+        accessibilityRole: "link",
+        disabled: isSubmitting,
+        style: styles.fieldGroup,
+        testID: withTestIdPrefix(AuthTestIds.otpResendButton, testIdPrefix),
+        onPress: onResend,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.linkText, children: isSubmitting ? labels.resending : labels.resend })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.changeEmail,
+        accessibilityLabel: labels.changeEmail,
+        accessibilityRole: "link",
+        disabled: isSubmitting,
+        testID: withTestIdPrefix(AuthTestIds.otpChangeEmailButton, testIdPrefix),
+        onPress: onChangeEmail,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.linkText, children: labels.changeEmail })
+      }
+    )
+  ] });
+}
+
+// src/hooks/OtpLoginStep.ts
+var OtpLoginStep = /* @__PURE__ */ ((OtpLoginStep2) => {
+  OtpLoginStep2["RequestCode"] = "requestCode";
+  OtpLoginStep2["EnterCode"] = "enterCode";
+  return OtpLoginStep2;
+})(OtpLoginStep || {});
+function toError2(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+var INITIAL_FLOW = {
+  step: "requestCode" /* RequestCode */,
+  identifier: "",
+  lastRequest: null
+};
+function useOtpLogin(options) {
+  const { client } = options;
+  const [flow, setFlow] = useState(INITIAL_FLOW);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const identifierRef = useRef("");
+  const beginAttempt = useCallback(() => {
+    if (mountedRef.current) {
+      setIsSubmitting(true);
+      setError(null);
+    }
+  }, []);
+  const endAttempt = useCallback(() => {
+    if (mountedRef.current) {
+      setIsSubmitting(false);
+    }
+  }, []);
+  const sendCode = useCallback(
+    async (identifier) => {
+      beginAttempt();
+      try {
+        const result = await client.requestOtp({ identifier });
+        identifierRef.current = identifier;
+        if (mountedRef.current) {
+          setFlow({ step: "enterCode" /* EnterCode */, identifier, lastRequest: result });
+        }
+        return result;
+      } catch (caught) {
+        const err = toError2(caught);
+        if (mountedRef.current) {
+          setError(err);
+        }
+        throw err;
+      } finally {
+        endAttempt();
+      }
+    },
+    [client, beginAttempt, endAttempt]
+  );
+  const requestCode = useCallback(
+    (identifier) => sendCode(identifier),
+    [sendCode]
+  );
+  const resend = useCallback(
+    () => sendCode(identifierRef.current),
+    [sendCode]
+  );
+  const verifyCode = useCallback(
+    async (otp) => {
+      beginAttempt();
+      try {
+        return await client.verifyOtp({ username: identifierRef.current, otp });
+      } catch (caught) {
+        const err = toError2(caught);
+        if (mountedRef.current) {
+          setError(err);
+        }
+        throw err;
+      } finally {
+        endAttempt();
+      }
+    },
+    [client, beginAttempt, endAttempt]
+  );
+  const reset = useCallback(() => {
+    identifierRef.current = "";
+    if (mountedRef.current) {
+      setFlow(INITIAL_FLOW);
+      setError(null);
+    }
+  }, []);
+  return useMemo(
+    () => ({
+      step: flow.step,
+      identifier: flow.identifier,
+      lastRequest: flow.lastRequest,
+      isSubmitting,
+      error,
+      requestCode,
+      verifyCode,
+      resend,
+      reset
+    }),
+    [
+      flow.step,
+      flow.identifier,
+      flow.lastRequest,
+      isSubmitting,
+      error,
+      requestCode,
+      verifyCode,
+      resend,
+      reset
+    ]
+  );
+}
+var EMAIL_REGEX2 = /^[^@\s]+@[^.\s]+\.[^\s]+$/;
+function isValidEmail2(value) {
+  return EMAIL_REGEX2.test(value);
+}
+function transportErrorFor(step, error, labels) {
+  if (error === null) {
+    return null;
+  }
+  return step === "requestCode" /* RequestCode */ ? labels.invalidEmail : labels.invalidCode;
+}
+function useRequestHandler(otp, labels, setLocalError) {
+  return useCallback(
+    (email) => {
+      setLocalError(null);
+      if (!isValidEmail2(email)) {
+        setLocalError(labels.invalidEmail);
+        return;
+      }
+      void otp.requestCode(email).catch(() => void 0);
+    },
+    [otp, labels.invalidEmail, setLocalError]
+  );
+}
+function useVerifyHandler(otp, labels, setLocalError, onSuccess) {
+  return useCallback(
+    (code) => {
+      setLocalError(null);
+      if (code.length === 0) {
+        setLocalError(labels.missingCode);
+        return;
+      }
+      otp.verifyCode(code).then((user) => {
+        onSuccess(user);
+      }).catch(() => void 0);
+    },
+    [otp, labels.missingCode, setLocalError, onSuccess]
+  );
+}
+function OtpForm({
+  client,
+  theme: themeProp,
+  labels: labelsProp,
+  onSuccess,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_OTP_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const otp = useOtpLogin({ client });
+  const [localError, setLocalError] = useState(null);
+  const handleRequest = useRequestHandler(otp, labels, setLocalError);
+  const handleVerify = useVerifyHandler(otp, labels, setLocalError, onSuccess);
+  const handleResend = useCallback(() => {
+    setLocalError(null);
+    void otp.resend().catch(() => void 0);
+  }, [otp]);
+  const handleChangeEmail = useCallback(() => {
+    setLocalError(null);
+    otp.reset();
+  }, [otp]);
+  const errorText = localError ?? transportErrorFor(otp.step, otp.error, labels);
+  return /* @__PURE__ */ jsx(View, { style: styles.screen, children: /* @__PURE__ */ jsx(View, { style: styles.card, testID: withTestIdPrefix(AuthTestIds.otpForm, testIdPrefix), children: otp.step === "requestCode" /* RequestCode */ ? /* @__PURE__ */ jsx(
+    OtpRequestStep,
+    {
+      errorText,
+      isSubmitting: otp.isSubmitting,
+      labels,
+      styles,
+      testIdPrefix,
+      theme,
+      onSubmit: handleRequest
+    }
+  ) : /* @__PURE__ */ jsx(
+    OtpVerifyStep,
+    {
+      errorText,
+      identifier: otp.identifier,
+      isSubmitting: otp.isSubmitting,
+      labels,
+      styles,
+      testIdPrefix,
+      theme,
+      onChangeEmail: handleChangeEmail,
+      onResend: handleResend,
+      onSubmit: handleVerify
+    }
+  ) }) });
+}
+function toError3(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function usePinLogin(options) {
+  const { client, eventExternalId } = options;
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const eventIdRef = useRef(eventExternalId);
+  useEffect(() => {
+    eventIdRef.current = eventExternalId;
+  }, [eventExternalId]);
+  const submit = useCallback(
+    async (pin) => {
+      if (mountedRef.current) {
+        setIsSubmitting(true);
+        setError(null);
+      }
+      try {
+        return await client.pinLogin({ pin, eventExternalId: eventIdRef.current });
+      } catch (caught) {
+        const err = toError3(caught);
+        if (mountedRef.current) {
+          setError(err);
+        }
+        throw err;
+      } finally {
+        if (mountedRef.current) {
+          setIsSubmitting(false);
+        }
+      }
+    },
+    [client]
+  );
+  const reset = useCallback(() => {
+    if (mountedRef.current) {
+      setError(null);
+    }
+  }, []);
+  return useMemo(
+    () => ({ isSubmitting, error, submit, reset }),
+    [isSubmitting, error, submit, reset]
+  );
+}
+function transportErrorFor2(error, labels) {
+  if (error === null) {
+    return null;
+  }
+  return labels.invalidPin;
+}
+function useSubmitHandler(pin, labels, setLocalError, onSuccess) {
+  return useCallback(
+    (value) => {
+      setLocalError(null);
+      if (value.length === 0) {
+        setLocalError(labels.missingPin);
+        return;
+      }
+      pin.submit(value).then((user) => {
+        onSuccess(user);
+      }).catch(() => void 0);
+    },
+    [pin, labels.missingPin, setLocalError, onSuccess]
+  );
+}
+function PinForm({
+  client,
+  eventExternalId,
+  theme: themeProp,
+  labels: labelsProp,
+  onSuccess,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_PIN_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const pin = usePinLogin({ client, eventExternalId });
+  const [localError, setLocalError] = useState(null);
+  const [pinValue, setPinValue] = useState("");
+  const handleSubmit = useSubmitHandler(pin, labels, setLocalError, onSuccess);
+  const errorText = localError ?? transportErrorFor2(pin.error, labels);
+  const buttonStyle = pin.isSubmitting ? [styles.primaryButton, styles.primaryButtonDisabled] : styles.primaryButton;
+  return /* @__PURE__ */ jsx(View, { style: styles.screen, children: /* @__PURE__ */ jsxs(View, { style: styles.card, testID: withTestIdPrefix(AuthTestIds.pinForm, testIdPrefix), children: [
+    /* @__PURE__ */ jsx(Text, { style: styles.title, children: labels.title }),
+    /* @__PURE__ */ jsx(Text, { style: styles.subtitle, children: labels.description }),
+    /* @__PURE__ */ jsxs(View, { style: styles.fieldGroup, children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.label, children: labels.pinLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          accessibilityHint: labels.pinPlaceholder,
+          accessibilityLabel: labels.pinLabel,
+          autoCapitalize: "none",
+          autoCorrect: false,
+          editable: !pin.isSubmitting,
+          keyboardType: "number-pad",
+          placeholder: labels.pinPlaceholder,
+          placeholderTextColor: theme.colors.textSecondary,
+          secureTextEntry: true,
+          style: styles.input,
+          testID: withTestIdPrefix(AuthTestIds.pinInput, testIdPrefix),
+          value: pinValue,
+          onChangeText: setPinValue
+        }
+      )
+    ] }),
+    errorText !== null ? /* @__PURE__ */ jsx(
+      Text,
+      {
+        style: styles.errorText,
+        testID: withTestIdPrefix(AuthTestIds.pinError, testIdPrefix),
+        children: errorText
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(
+      TouchableOpacity,
+      {
+        accessibilityHint: labels.submit,
+        accessibilityLabel: pin.isSubmitting ? labels.submitting : labels.submit,
+        accessibilityRole: "button",
+        disabled: pin.isSubmitting,
+        style: buttonStyle,
+        testID: withTestIdPrefix(AuthTestIds.pinSubmitButton, testIdPrefix),
+        onPress: () => handleSubmit(pinValue.trim()),
+        children: pin.isSubmitting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.onPrimary, size: "small" }) : /* @__PURE__ */ jsx(Text, { style: styles.primaryButtonText, children: labels.submit })
+      }
+    )
+  ] }) });
+}
+async function lazyFetchHttpClient(request) {
+  const fetchImpl = typeof fetch === "function" ? fetch.bind(globalThis) : void 0;
+  if (fetchImpl === void 0) {
+    throw new Error("createBffAuthClient: fetch is not available in this environment");
+  }
+  return createFetchHttpClient(fetchImpl)(request);
+}
+function createBffAuthClient(options = {}) {
+  return new BffAuthClient({
+    http: options.http ?? lazyFetchHttpClient,
+    baseUrl: options.baseUrl
+  });
+}
+
+// src/router/resolvePostLoginRoute.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readRealmAccessRoles(realmAccess) {
+  if (!isRecord(realmAccess)) {
+    return [];
+  }
+  const roles = realmAccess.roles;
+  if (!Array.isArray(roles)) {
+    return [];
+  }
+  return roles.filter((role) => typeof role === "string");
+}
+function collectUserRoles(user) {
+  const flat = Array.isArray(user.roles) ? user.roles.filter((role) => typeof role === "string") : [];
+  const realm = readRealmAccessRoles(user.realm_access);
+  return Array.from(/* @__PURE__ */ new Set([...flat, ...realm]));
+}
+function resolvePostLoginRoute(user, table) {
+  const userRoles = new Set(collectUserRoles(user));
+  for (const entry of table.routes) {
+    if (userRoles.has(entry.role)) {
+      return entry.route;
+    }
+  }
+  return table.fallback ?? null;
+}
+
+export { AuthTestIds, AuthThemeProvider, BffAuthStatus, DEFAULT_FORGOT_PASSWORD_LABELS, DEFAULT_LOGIN_LABELS, DEFAULT_OTP_LABELS, DEFAULT_PIN_LABELS, DEFAULT_RESET_PASSWORD_LABELS, ForgotPasswordForm, LoginForm, OtpForm, OtpLoginStep, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PasswordPolicyError, PinForm, ResetPasswordError, ResetPasswordForm, collectUserRoles, createBffAuthClient, defaultAuthTheme, isPasswordValid, resolvePostLoginRoute, useAuthTheme, useBffAuth, useBffForgotPassword, useBffResetPassword, useOtpLogin, usePinLogin, useResetPasswordForm, validatePasswordPolicy, withTestIdPrefix };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map