@dloizides/auth-web 1.4.0 → 1.5.0

package/dist/index.mjs

@@ -139,6 +139,21 @@ var DEFAULT_PASSKEY_SETTINGS_LABELS = {
   addHint: "Start setting up a passkey for this account",
   registeredSuccess: "Your passkey was added. You can now use it to sign in."
 };
+var DEFAULT_PREFERRED_METHOD_SETTINGS_LABELS = {
+  title: "Preferred sign-in method",
+  description: "Pick how you usually sign in. We will show this method first on your devices.",
+  noPreference: "No preference",
+  methodPassword: "Password",
+  methodPin: "Quick PIN",
+  methodPasskey: "Passkey",
+  saving: "Saving...",
+  saveFailed: "Could not save your preference. Try again later."
+};
+var DEFAULT_PREFERRED_METHOD_HINT_LABELS = {
+  password: "You usually sign in with your password.",
+  pin: "You usually sign in with your quick PIN on this account.",
+  passkey: "You usually sign in with a passkey."
+};
 var DEFAULT_RESET_PASSWORD_LABELS = {
   title: "Reset password",
   description: "Choose a new password for your account.",
@@ -219,7 +234,14 @@ var AuthTestIds = {
   // Passkey settings card
   passkeySettings: "auth-passkey-settings",
   passkeySettingsAdd: "auth-passkey-settings-add",
-  passkeySettingsSuccess: "auth-passkey-settings-success"
+  passkeySettingsSuccess: "auth-passkey-settings-success",
+  // Preferred-method settings card (cross-device default-method picker).
+  // Each option row appends `-${method}` to `preferredMethodSettingsOption`.
+  preferredMethodSettings: "auth-preferred-method-settings",
+  preferredMethodSettingsOption: "auth-preferred-method-settings-option",
+  preferredMethodSettingsError: "auth-preferred-method-settings-error",
+  // Preferred-method login-screen hint
+  preferredMethodHint: "auth-preferred-method-hint"
 };
 function withTestIdPrefix(baseId, prefix) {
   return prefix === void 0 || prefix === "" ? baseId : `${prefix}-${baseId}`;
@@ -2526,6 +2548,217 @@ function PasskeySettingsCard({
     }
   );
 }
+
+// src/preferences/preferredMethodCache.ts
+var CACHE_KEY = "dloizides.auth.preferredLoginMethod";
+function safeStorage() {
+  try {
+    if (typeof localStorage === "undefined") {
+      return null;
+    }
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function readCachedPreferredMethod() {
+  const store = safeStorage();
+  if (store === null) {
+    return null;
+  }
+  try {
+    const value = store.getItem(CACHE_KEY);
+    return value === null || value === "" ? null : value;
+  } catch {
+    return null;
+  }
+}
+function cachePreferredMethod(method) {
+  const store = safeStorage();
+  if (store === null) {
+    return;
+  }
+  try {
+    if (method === null || method === "") {
+      store.removeItem(CACHE_KEY);
+      return;
+    }
+    store.setItem(CACHE_KEY, method);
+  } catch {
+  }
+}
+function clearCachedPreferredMethod() {
+  cachePreferredMethod(null);
+}
+
+// src/preferences/usePreferredMethodSetting.ts
+function usePreferredMethodSetting({
+  client,
+  onChanged
+}) {
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [failed, setFailed] = useState(false);
+  const [selected, setSelected] = useState(null);
+  useEffect(() => {
+    let active = true;
+    client.getPreferredLoginMethod().then((method) => {
+      if (active) {
+        setSelected(method);
+      }
+    }).catch(() => {
+    }).finally(() => {
+      if (active) {
+        setLoading(false);
+      }
+    });
+    return () => {
+      active = false;
+    };
+  }, [client]);
+  const select = useCallback(
+    (method) => {
+      const previous = selected;
+      if (method === previous) {
+        return;
+      }
+      setFailed(false);
+      setSaving(true);
+      setSelected(method);
+      client.setPreferredLoginMethod(method).then((ok) => {
+        if (ok) {
+          cachePreferredMethod(method);
+          onChanged?.(method);
+          return;
+        }
+        setSelected(previous);
+        setFailed(true);
+      }).catch(() => {
+        setSelected(previous);
+        setFailed(true);
+      }).finally(() => {
+        setSaving(false);
+      });
+    },
+    [client, selected, onChanged]
+  );
+  return { loading, saving, failed, selected, select };
+}
+var NO_PREFERENCE = "__none__";
+function methodDisplayName(method, labels) {
+  if (method === "password") {
+    return labels.methodPassword;
+  }
+  if (method === "pin") {
+    return labels.methodPin;
+  }
+  if (method === "passkey") {
+    return labels.methodPasskey;
+  }
+  return method;
+}
+function PreferredMethodSettingsCard({
+  client,
+  availableMethods,
+  theme: themeProp,
+  labels: labelsProp,
+  testIdPrefix,
+  onChanged
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles3 = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_PREFERRED_METHOD_SETTINGS_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const { loading, saving, failed, selected, select } = usePreferredMethodSetting({
+    client,
+    onChanged
+  });
+  const options = useMemo(
+    () => [
+      { value: null, key: NO_PREFERENCE, label: labels.noPreference },
+      ...availableMethods.map((method) => ({
+        value: method,
+        key: method,
+        label: methodDisplayName(method, labels)
+      }))
+    ],
+    [availableMethods, labels]
+  );
+  return /* @__PURE__ */ jsxs(
+    View,
+    {
+      style: styles3.card,
+      testID: withTestIdPrefix(AuthTestIds.preferredMethodSettings, testIdPrefix),
+      children: [
+        /* @__PURE__ */ jsx(Text, { style: styles3.title, children: labels.title }),
+        /* @__PURE__ */ jsx(Text, { style: styles3.subtitle, children: labels.description }),
+        loading ? /* @__PURE__ */ jsx(ActivityIndicator, { color: theme.colors.primary, size: "small" }) : options.map((option) => {
+          const isSelected = option.value === selected;
+          const optionTestId = `${withTestIdPrefix(
+            AuthTestIds.preferredMethodSettingsOption,
+            testIdPrefix
+          )}-${option.key}`;
+          return /* @__PURE__ */ jsx(
+            TouchableOpacity,
+            {
+              accessibilityHint: labels.description,
+              accessibilityLabel: option.label,
+              accessibilityRole: "radio",
+              accessibilityState: { selected: isSelected },
+              disabled: saving,
+              style: isSelected ? styles3.secondaryButton : styles3.escapeLink,
+              testID: optionTestId,
+              onPress: () => select(option.value),
+              children: /* @__PURE__ */ jsx(Text, { style: isSelected ? styles3.secondaryButtonText : styles3.linkText, children: isSelected ? `\u2713 ${option.label}` : option.label })
+            },
+            option.key
+          );
+        }),
+        saving ? /* @__PURE__ */ jsx(Text, { style: styles3.helperText, children: labels.saving }) : null,
+        failed ? /* @__PURE__ */ jsx(
+          Text,
+          {
+            style: styles3.errorText,
+            testID: withTestIdPrefix(AuthTestIds.preferredMethodSettingsError, testIdPrefix),
+            children: labels.saveFailed
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function hintFor(method, labels) {
+  if (method === "password") {
+    return labels.password;
+  }
+  if (method === "pin") {
+    return labels.pin;
+  }
+  if (method === "passkey") {
+    return labels.passkey;
+  }
+  return null;
+}
+function PreferredMethodHint({
+  method,
+  theme: themeProp,
+  labels: labelsProp,
+  testIdPrefix
+}) {
+  const theme = useAuthTheme(themeProp);
+  const styles3 = useAuthStyles(theme);
+  const labels = useMemo(
+    () => ({ ...DEFAULT_PREFERRED_METHOD_HINT_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const text = hintFor(method, labels);
+  if (text === null) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(View, { testID: withTestIdPrefix(AuthTestIds.preferredMethodHint, testIdPrefix), children: /* @__PURE__ */ jsx(Text, { style: styles3.helperText, children: text }) });
+}
 var EMPTY_CONFIG = {
   methods: [],
   registrationEnabled: false,
@@ -2560,6 +2793,77 @@ function useBffLoginConfig(client) {
   }, [client]);
   return { config, loading };
 }
+
+// src/preferences/preferencesClient.ts
+var CSRF_HEADER = "X-BFF-Csrf";
+var CSRF_HEADER_VALUE = "1";
+var JSON_CONTENT_TYPE = "application/json";
+var DEFAULT_TENANTS_SEGMENT = "tenants";
+var PREFERENCES_PATH = "api/v1/me/preferences";
+var LOGIN_METHOD_PREFERENCE_PATH = "api/v1/me/login-method-preference";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readOptionalString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string" || value === "") {
+    return null;
+  }
+  return value;
+}
+function createPreferencesClient(options) {
+  const http = options.http;
+  const baseUrl = (options.baseUrl ?? "").replace(/\/$/, "");
+  const segment = options.tenantsSegment ?? DEFAULT_TENANTS_SEGMENT;
+  const proxyBase = `${baseUrl}/bff/api/${segment}`;
+  return {
+    async getPreferredLoginMethod() {
+      try {
+        const response = await http({
+          url: `${proxyBase}/${PREFERENCES_PATH}`,
+          method: "GET",
+          headers: { Accept: JSON_CONTENT_TYPE },
+          credentials: "include"
+        });
+        if (!response.ok || !isRecord(response.data)) {
+          return null;
+        }
+        return readOptionalString(response.data, "preferredLoginMethod");
+      } catch {
+        return null;
+      }
+    },
+    async setPreferredLoginMethod(method) {
+      try {
+        const response = await http({
+          url: `${proxyBase}/${LOGIN_METHOD_PREFERENCE_PATH}`,
+          method: "PUT",
+          headers: {
+            "Content-Type": JSON_CONTENT_TYPE,
+            Accept: JSON_CONTENT_TYPE,
+            [CSRF_HEADER]: CSRF_HEADER_VALUE
+          },
+          body: JSON.stringify({ method }),
+          credentials: "include"
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/preferences/syncPreferredMethodCache.ts
+async function syncPreferredMethodFromServer(client) {
+  try {
+    const method = await client.getPreferredLoginMethod();
+    cachePreferredMethod(method);
+    return method;
+  } catch {
+    return null;
+  }
+}
 async function lazyFetchHttpClient(request) {
   const fetchImpl = typeof fetch === "function" ? fetch.bind(globalThis) : void 0;
   if (fetchImpl === void 0) {
@@ -2575,11 +2879,11 @@ function createBffAuthClient(options = {}) {
 }
 
 // src/router/resolvePostLoginRoute.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function readRealmAccessRoles(realmAccess) {
-  if (!isRecord(realmAccess)) {
+  if (!isRecord2(realmAccess)) {
     return [];
   }
   const roles = realmAccess.roles;
@@ -2603,6 +2907,6 @@ function resolvePostLoginRoute(user, table) {
   return table.fallback ?? null;
 }
 
-export { AuthTestIds, AuthThemeProvider, BffAuthStatus, DEFAULT_DEVICE_PIN_ENROLL_LABELS, DEFAULT_DEVICE_PIN_SETTINGS_LABELS, DEFAULT_DEVICE_PIN_UNLOCK_LABELS, DEFAULT_FORGOT_PASSWORD_FIELDS_LABELS, DEFAULT_FORGOT_PASSWORD_LABELS, DEFAULT_LOGIN_LABELS, DEFAULT_OTP_LABELS, DEFAULT_PASSKEY_LOGIN_LABELS, DEFAULT_PASSKEY_SETTINGS_LABELS, DEFAULT_PIN_LABELS, DEFAULT_RESET_PASSWORD_LABELS, DEVICE_PIN_ALLOWED_DIGITS, DEVICE_PIN_DEFAULT_DIGITS, DevicePinEnrollErrorKey, DevicePinEnrollForm, DevicePinErrorKey, DevicePinInput, DevicePinLengthPicker, DevicePinOffer, DevicePinSettingsCard, DevicePinUnlockScreen, ForgotPasswordFields, ForgotPasswordForm, LoginForm, OtpForm, OtpLoginStep, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PasskeyLoginButton, PasskeySettingsCard, PasswordPolicyError, PinForm, ResetPasswordError, ResetPasswordForm, collectUserRoles, createBffAuthClient, defaultAuthTheme, isAllowedPinDigits, isPasswordValid, isValidForgotPasswordEmail, readPasskeyError, readPasskeyRegistered, resolvePostLoginRoute, startPasskeyLogin, startPasskeyRegistration, useAuthTheme, useBffAuth, useBffForgotPassword, useBffLoginConfig, useBffResetPassword, useDevicePinDisable, useDevicePinEnroll, useDevicePinUnlock, useForgotPasswordSubmit, useOtpLogin, usePinLogin, useResetPasswordForm, validatePasswordPolicy, withTestIdPrefix };
+export { AuthTestIds, AuthThemeProvider, BffAuthStatus, DEFAULT_DEVICE_PIN_ENROLL_LABELS, DEFAULT_DEVICE_PIN_SETTINGS_LABELS, DEFAULT_DEVICE_PIN_UNLOCK_LABELS, DEFAULT_FORGOT_PASSWORD_FIELDS_LABELS, DEFAULT_FORGOT_PASSWORD_LABELS, DEFAULT_LOGIN_LABELS, DEFAULT_OTP_LABELS, DEFAULT_PASSKEY_LOGIN_LABELS, DEFAULT_PASSKEY_SETTINGS_LABELS, DEFAULT_PIN_LABELS, DEFAULT_PREFERRED_METHOD_HINT_LABELS, DEFAULT_PREFERRED_METHOD_SETTINGS_LABELS, DEFAULT_RESET_PASSWORD_LABELS, DEVICE_PIN_ALLOWED_DIGITS, DEVICE_PIN_DEFAULT_DIGITS, DevicePinEnrollErrorKey, DevicePinEnrollForm, DevicePinErrorKey, DevicePinInput, DevicePinLengthPicker, DevicePinOffer, DevicePinSettingsCard, DevicePinUnlockScreen, ForgotPasswordFields, ForgotPasswordForm, LoginForm, OtpForm, OtpLoginStep, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PasskeyLoginButton, PasskeySettingsCard, PasswordPolicyError, PinForm, PreferredMethodHint, PreferredMethodSettingsCard, ResetPasswordError, ResetPasswordForm, cachePreferredMethod, clearCachedPreferredMethod, collectUserRoles, createBffAuthClient, createPreferencesClient, defaultAuthTheme, isAllowedPinDigits, isPasswordValid, isValidForgotPasswordEmail, readCachedPreferredMethod, readPasskeyError, readPasskeyRegistered, resolvePostLoginRoute, startPasskeyLogin, startPasskeyRegistration, syncPreferredMethodFromServer, useAuthTheme, useBffAuth, useBffForgotPassword, useBffLoginConfig, useBffResetPassword, useDevicePinDisable, useDevicePinEnroll, useDevicePinUnlock, useForgotPasswordSubmit, useOtpLogin, usePinLogin, usePreferredMethodSetting, useResetPasswordForm, validatePasswordPolicy, withTestIdPrefix };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map