@sparkvault/sdk-mobile 5.3.0 → 6.0.0

package/src/identity-dialog.tsx

@@ -19,31 +19,30 @@ import type {
   IdentityMethodId,
   IdentityType,
   IdentityVerifyResult,
-  PasskeyAuthOptions,
-  PasskeyCredential,
 } from './types.js';
 
-type DialogStep = 'loading' | 'identity' | 'methods' | 'passkey' | 'otp' | 'error';
+type DialogStep = 'loading' | 'identity' | 'methods' | 'otp' | 'error';
 type OtpMethod = 'email' | 'sms' | 'voice';
-type SupportedMethodId = 'passkey' | 'otp_email' | 'otp_sms' | 'otp_voice';
-
-export interface MobilePasskeyProvider {
-  isSupported(): boolean | Promise<boolean>;
-  authenticate(options: PasskeyAuthOptions): Promise<PasskeyCredential | null>;
-}
+type SupportedMethodId = 'otp_email' | 'otp_sms' | 'otp_voice';
 
 export interface SparkVaultIdentityDialogProps {
   client: SparkVaultMobile;
   visible: boolean;
   initialIdentity?: string;
   initialIdentityType?: IdentityType;
-  passkeyProvider?: MobilePasskeyProvider;
   onSuccess(result: IdentityVerifyResult & { jwks: IdentityJwks }): void | Promise<void>;
   onCancel(): void;
   onError?(error: Error): void;
 }
 
-const SUPPORTED_METHODS = new Set<IdentityMethodId>(['passkey', 'otp_email', 'otp_sms', 'otp_voice']);
+/**
+ * Sign-in here is one-time code only. Passkeys are an Identity Product method
+ * on the web, but the native ceremony does not work in the mobile app, so the
+ * dialog never offers one: a tenant with `passkey` enabled server-side simply
+ * sees the code methods. `products.identity` still exposes the passkey APIs
+ * for a host that drives the ceremony itself.
+ */
+const SUPPORTED_METHODS = new Set<IdentityMethodId>(['otp_email', 'otp_sms', 'otp_voice']);
 const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 const E164_PHONE_REGEX = /^\+[1-9]\d{7,14}$/;
 
@@ -52,7 +51,6 @@ export function SparkVaultIdentityDialog({
   visible,
   initialIdentity,
   initialIdentityType,
-  passkeyProvider,
   onSuccess,
   onCancel,
   onError,
@@ -68,6 +66,10 @@ export function SparkVaultIdentityDialog({
   const [countdown, setCountdown] = useState('');
   const [isBusy, setIsBusy] = useState(false);
   const [error, setError] = useState('');
+  /** The branding logo's own proportions, once the image has reported them. */
+  const [measuredLogo, setMeasuredLogo] = useState<{ uri: string; aspectRatio: number } | null>(null);
+  /** A branding logo that failed to load, so the header falls back to the name. */
+  const [brokenLogoUri, setBrokenLogoUri] = useState<string | null>(null);
   const sessionRef = useRef(0);
   const onSuccessRef = useRef(onSuccess);
   const onCancelRef = useRef(onCancel);
@@ -77,15 +79,10 @@ export function SparkVaultIdentityDialog({
   const effectiveTheme = branding?.themeMode ?? 'light';
   const colors = effectiveTheme === 'dark' ? darkColors : lightColors;
   const allowedTypes = useMemo(() => normalizeAllowedTypes(config), [config]);
-  const methodsForIdentity = useMemo(
-    () => getMethodsForIdentity(config, identityType, passkeyProvider),
-    [config, identityType, passkeyProvider]
-  );
-  const methodsWithoutIdentity = useMemo(
-    () => getMethodsWithoutIdentity(config, passkeyProvider),
-    [config, passkeyProvider]
+  const visibleMethods = useMemo(
+    () => getMethodsForIdentity(config, identityType),
+    [config, identityType]
   );
-  const visibleMethods = allowedTypes.length > 0 ? methodsForIdentity : methodsWithoutIdentity;
 
   useEffect(() => {
     onSuccessRef.current = onSuccess;
@@ -108,6 +105,7 @@ export function SparkVaultIdentityDialog({
     setKindling(null);
     setExpiresAt(null);
     setSelectedMethod(null);
+    setBrokenLogoUri(null);
     setIdentity(initialIdentity ?? '');
     setIdentityType(initialIdentityType ?? 'email');
 
@@ -119,8 +117,6 @@ export function SparkVaultIdentityDialog({
         setIdentityType(resolveInitialIdentityType(initialIdentity, initialIdentityType, nextAllowedTypes));
         if (nextAllowedTypes.length > 0) {
           setStep('identity');
-        } else if (getMethodsWithoutIdentity(nextConfig, passkeyProvider).length > 0) {
-          setStep('methods');
         } else {
           setError('No supported sign-in methods are enabled for this app.');
           setStep('error');
@@ -137,7 +133,7 @@ export function SparkVaultIdentityDialog({
     return () => {
       cancelled = true;
     };
-  }, [client, initialIdentity, initialIdentityType, passkeyProvider, visible]);
+  }, [client, initialIdentity, initialIdentityType, visible]);
 
   useEffect(() => {
     if (!expiresAt || step !== 'otp') {
@@ -178,9 +174,6 @@ export function SparkVaultIdentityDialog({
     targetIdentity = identity,
     targetIdentityType = identityType
   ) => {
-    const otpMethod = toOtpMethod(method);
-    if (!otpMethod) return;
-
     const sessionId = sessionRef.current;
     setIsBusy(true);
     setError('');
@@ -189,7 +182,7 @@ export function SparkVaultIdentityDialog({
       const response = await client.products.identity.sendOtp({
         identity: targetIdentity,
         identityType: targetIdentityType,
-        method: otpMethod,
+        method: toOtpMethod(method),
       });
       if (!isActiveSession(sessionRef, sessionId)) return;
       setKindling(response.kindling);
@@ -206,45 +199,6 @@ export function SparkVaultIdentityDialog({
     }
   }, [client, identity, identityType, reportError]);
 
-  const runPasskey = useCallback(async () => {
-    if (!passkeyProvider) {
-      setError('Passkeys are not available in this app.');
-      return;
-    }
-
-    const sessionId = sessionRef.current;
-    setIsBusy(true);
-    setError('');
-    setSelectedMethod('passkey');
-    setStep('passkey');
-
-    try {
-      const supported = await passkeyProvider.isSupported();
-      if (!supported) {
-        throw new Error('Passkeys are not supported on this device.');
-      }
-      if (!isActiveSession(sessionRef, sessionId)) return;
-
-      const challenge = await client.products.identity.getPasskeyAuthOptions();
-      if (!isActiveSession(sessionRef, sessionId)) return;
-      const credential = await passkeyProvider.authenticate(challenge.options);
-      if (!isActiveSession(sessionRef, sessionId)) return;
-      if (!credential) {
-        throw new Error('Passkey authentication was cancelled.');
-      }
-
-      const result = await client.products.identity.completePasskeyAuthentication(credential, challenge.session);
-      await finishWithToken(result, sessionId);
-    } catch (err) {
-      if (!isActiveSession(sessionRef, sessionId)) return;
-      reportError(err, 'Passkey authentication failed');
-    } finally {
-      if (isActiveSession(sessionRef, sessionId)) {
-        setIsBusy(false);
-      }
-    }
-  }, [client, finishWithToken, passkeyProvider, reportError]);
-
   const handleIdentitySubmit = useCallback(async () => {
     if (isBusy) return;
 
@@ -256,7 +210,7 @@ export function SparkVaultIdentityDialog({
 
     const normalizedIdentity = parsed.identity;
     const nextIdentityType = parsed.identityType;
-    const availableMethods = getMethodsForIdentity(config, nextIdentityType, passkeyProvider);
+    const availableMethods = getMethodsForIdentity(config, nextIdentityType);
     if (availableMethods.length === 0) {
       setError('No supported sign-in methods are enabled for this identity type.');
       return;
@@ -265,37 +219,16 @@ export function SparkVaultIdentityDialog({
     setIdentity(normalizedIdentity);
     setIdentityType(nextIdentityType);
     setError('');
-    setIsBusy(true);
-    const sessionId = sessionRef.current;
-
-    try {
-      if (availableMethods.length === 1) {
-        if (availableMethods[0] === 'passkey') {
-          await runPasskey();
-        } else {
-          await sendOtp(availableMethods[0], normalizedIdentity, nextIdentityType);
-        }
-        return;
-      }
-
-      setStep('methods');
-    } catch (err) {
-      if (!isActiveSession(sessionRef, sessionId)) return;
-      reportError(err, 'Failed to load sign-in methods');
-    } finally {
-      if (isActiveSession(sessionRef, sessionId)) {
-        setIsBusy(false);
-      }
-    }
-  }, [allowedTypes, config, identity, isBusy, passkeyProvider, reportError, runPasskey, sendOtp]);
 
-  const handleMethodSelect = useCallback(async (method: SupportedMethodId) => {
-    if (method === 'passkey') {
-      await runPasskey();
+    // One way in: send that code. Several (a phone with both SMS and voice):
+    // let the person choose. sendOtp owns the busy flag and its own failures.
+    if (availableMethods.length === 1) {
+      await sendOtp(availableMethods[0], normalizedIdentity, nextIdentityType);
       return;
     }
-    await sendOtp(method);
-  }, [runPasskey, sendOtp]);
+
+    setStep('methods');
+  }, [allowedTypes, config, identity, isBusy, sendOtp]);
 
   const handleVerifyOtp = useCallback(async () => {
     if (!kindling || pin.length !== 6) return;
@@ -349,8 +282,6 @@ export function SparkVaultIdentityDialog({
         setIdentityType(resolveInitialIdentityType(initialIdentity, initialIdentityType, nextAllowedTypes));
         if (nextAllowedTypes.length > 0) {
           setStep('identity');
-        } else if (getMethodsWithoutIdentity(nextConfig, passkeyProvider).length > 0) {
-          setStep('methods');
         } else {
           setError('No supported sign-in methods are enabled for this app.');
           setStep('error');
@@ -366,10 +297,16 @@ export function SparkVaultIdentityDialog({
           setIsBusy(false);
         }
       });
-  }, [client, initialIdentity, initialIdentityType, passkeyProvider, reportError]);
+  }, [client, initialIdentity, initialIdentityType, reportError]);
 
-  const headerLogo = getHeaderLogo(branding, effectiveTheme);
   const companyName = branding?.companyName || 'SparkVault';
+  // A logo speaks for the brand on its own, so it replaces the company name
+  // rather than sitting beside it, drawn at its own proportions and the full
+  // height of the header instead of squeezed into a square. Only a logo that
+  // loads earns that: one that fails falls back to the lettermark and name, so
+  // the header is never blank.
+  const logoUri = resolveLogoUri(branding, effectiveTheme, brokenLogoUri);
+  const logoAspectRatio = measuredLogo?.uri === logoUri ? measuredLogo.aspectRatio : null;
 
   return (
     <Modal visible={visible} transparent animationType="fade" onRequestClose={handleCancel}>
@@ -384,16 +321,39 @@ export function SparkVaultIdentityDialog({
           <View style={[styles.card, { backgroundColor: colors.card, borderColor: colors.border }]}>
             <View style={styles.header}>
               <View style={styles.brand}>
-                {headerLogo ? (
-                  <Image source={{ uri: headerLogo }} style={styles.logo} resizeMode="contain" />
+                {logoUri ? (
+                  <Image
+                    source={{ uri: logoUri }}
+                    style={
+                      logoAspectRatio === null
+                        ? styles.logoUnmeasured
+                        : [styles.logo, { aspectRatio: logoAspectRatio }]
+                    }
+                    resizeMode="contain"
+                    accessibilityRole="image"
+                    accessibilityLabel={companyName}
+                    onLoad={(event) => {
+                      const { width, height } = event.nativeEvent.source;
+                      if (width <= 0 || height <= 0) return;
+                      const aspectRatio = width / height;
+                      setMeasuredLogo(current => (
+                        current?.uri === logoUri && current.aspectRatio === aspectRatio
+                          ? current
+                          : { uri: logoUri, aspectRatio }
+                      ));
+                    }}
+                    onError={() => setBrokenLogoUri(logoUri)}
+                  />
                 ) : (
-                  <View style={[styles.logoFallback, { backgroundColor: colors.primarySoft }]}>
-                    <Text style={[styles.logoFallbackText, { color: colors.primary }]}>
-                      {companyName.slice(0, 1).toUpperCase()}
-                    </Text>
-                  </View>
+                  <>
+                    <View style={[styles.logoFallback, { backgroundColor: colors.primarySoft }]}>
+                      <Text style={[styles.logoFallbackText, { color: colors.primary }]}>
+                        {companyName.slice(0, 1).toUpperCase()}
+                      </Text>
+                    </View>
+                    <Text style={[styles.companyName, { color: colors.text }]}>{companyName}</Text>
+                  </>
                 )}
-                <Text style={[styles.companyName, { color: colors.text }]}>{companyName}</Text>
               </View>
               <Pressable
                 accessibilityRole="button"
@@ -464,7 +424,7 @@ export function SparkVaultIdentityDialog({
                     <Pressable
                       key={method}
                       accessibilityRole="button"
-                      onPress={() => handleMethodSelect(method)}
+                      onPress={() => sendOtp(method)}
                       disabled={isBusy}
                       style={({ pressed }) => [
                         styles.methodButton,
@@ -489,35 +449,6 @@ export function SparkVaultIdentityDialog({
               </View>
             )}
 
-            {step === 'passkey' && (
-              <View style={styles.body}>
-                <Text style={[styles.title, { color: colors.text }]}>Use your passkey</Text>
-                <Text style={[styles.subtitle, { color: colors.muted }]}>
-                  Confirm this sign-in with your device passkey.
-                </Text>
-                <View style={[styles.passkeyIcon, { backgroundColor: colors.primarySoft }]}>
-                  <Text style={styles.passkeyIconText}>🔑</Text>
-                </View>
-                {isBusy ? <ActivityIndicator color={colors.primary} /> : null}
-                {error ? <Text style={[styles.error, { color: colors.error }]}>{error}</Text> : null}
-                <PrimaryButton
-                  label="Try Again"
-                  colors={colors}
-                  disabled={isBusy}
-                  loading={isBusy}
-                  onPress={runPasskey}
-                />
-                {allowedTypes.length > 0 && fallbackOtpMethod(methodsForIdentity) ? (
-                  <TextButton
-                    label={fallbackLabel(fallbackOtpMethod(methodsForIdentity)!)}
-                    colors={colors}
-                    onPress={() => sendOtp(fallbackOtpMethod(methodsForIdentity)!)}
-                    disabled={isBusy}
-                  />
-                ) : null}
-              </View>
-            )}
-
             {step === 'otp' && (
               <View style={styles.body}>
                 <Text style={[styles.title, { color: colors.text }]}>{otpTitle(selectedMethod)}</Text>
@@ -662,28 +593,16 @@ function resolveInitialIdentityType(
 
 function getMethodsForIdentity(
   config: IdentityConfig | null,
-  identityType: IdentityType,
-  passkeyProvider?: MobilePasskeyProvider
+  identityType: IdentityType
 ): SupportedMethodId[] {
   const configuredMethods = config?.methods ?? ['otp_email'];
   return configuredMethods.filter((method): method is SupportedMethodId => {
     if (!SUPPORTED_METHODS.has(method)) return false;
-    if (method === 'passkey') return Boolean(passkeyProvider);
     if (method === 'otp_email') return identityType === 'email';
     return identityType === 'phone';
   });
 }
 
-function getMethodsWithoutIdentity(
-  config: IdentityConfig | null,
-  passkeyProvider?: MobilePasskeyProvider
-): SupportedMethodId[] {
-  const configuredMethods = config?.methods ?? [];
-  return configuredMethods.filter((method): method is SupportedMethodId => (
-    method === 'passkey' && Boolean(passkeyProvider)
-  ));
-}
-
 function parseIdentity(
   value: string,
   allowedTypes: IdentityType[]
@@ -716,32 +635,19 @@ function parseIdentity(
   return { ok: true, identity: phone, identityType: 'phone' };
 }
 
-function toOtpMethod(method: SupportedMethodId): OtpMethod | null {
-  if (method === 'otp_email') return 'email';
+function toOtpMethod(method: SupportedMethodId): OtpMethod {
   if (method === 'otp_sms') return 'sms';
   if (method === 'otp_voice') return 'voice';
-  return null;
-}
-
-function fallbackOtpMethod(methods: SupportedMethodId[]): SupportedMethodId | null {
-  return methods.find((method) => method !== 'passkey') ?? null;
-}
-
-function fallbackLabel(method: SupportedMethodId): string {
-  if (method === 'otp_sms') return 'Use SMS code instead';
-  if (method === 'otp_voice') return 'Use voice call instead';
-  return 'Use email code instead';
+  return 'email';
 }
 
 function methodTitle(method: SupportedMethodId): string {
-  if (method === 'passkey') return 'Passkey';
   if (method === 'otp_sms') return 'Text message';
   if (method === 'otp_voice') return 'Voice call';
   return 'Email code';
 }
 
 function methodDescription(method: SupportedMethodId): string {
-  if (method === 'passkey') return 'Use Face ID, Touch ID, or your device passcode.';
   if (method === 'otp_sms') return 'Receive a one-time code by SMS.';
   if (method === 'otp_voice') return 'Receive a one-time code by phone call.';
   return 'Receive a one-time code by email.';
@@ -765,11 +671,16 @@ function otpTitle(method: SupportedMethodId | null): string {
   return 'Check your email';
 }
 
-function getHeaderLogo(branding: IdentityConfig['branding'], theme: 'light' | 'dark'): string | null {
+function resolveLogoUri(
+  branding: IdentityConfig['branding'],
+  theme: 'light' | 'dark',
+  brokenLogoUri: string | null
+): string | null {
   if (!branding) return null;
-  return theme === 'dark'
+  const uri = theme === 'dark'
     ? branding.logoDark || branding.logoLight
     : branding.logoLight || branding.logoDark;
+  return uri && uri !== brokenLogoUri ? uri : null;
 }
 
 function formatCountdown(seconds: number): string {
@@ -850,9 +761,17 @@ const styles = StyleSheet.create({
     alignItems: 'center',
   },
   logo: {
-    width: 32,
-    height: 32,
-    marginRight: 10,
+    // Height is the header's; width follows the logo's own aspect ratio,
+    // bounded by the space left beside the close button.
+    height: 40,
+    maxWidth: '100%',
+  },
+  logoUnmeasured: {
+    // Before the image reports its shape. A square, not a zero-width box: iOS
+    // only loads an image into a non-zero frame, and a box with no width would
+    // leave the header permanently empty.
+    height: 40,
+    width: 40,
   },
   logoFallback: {
     width: 32,
@@ -965,15 +884,4 @@ const styles = StyleSheet.create({
     fontSize: 13,
     lineHeight: 18,
   },
-  passkeyIcon: {
-    width: 76,
-    height: 76,
-    borderRadius: 38,
-    alignSelf: 'center',
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  passkeyIconText: {
-    fontSize: 34,
-  },
 });

package/src/index.ts

@@ -93,6 +93,7 @@ export {
   MobileUsersClient,
 } from './users.js';
 export {
+  isSessionGone,
   MobileTusUploader,
   parseForgeUrl,
 } from './tus.js';

package/src/ingots.ts

@@ -907,11 +907,16 @@ export class MobileIngotsClient {
     }
   }
 
+  /**
+   * The two typed cancel signals: the adapter's contract (an Error named
+   * `AbortError`, see `MobileFileDownloader`) and the SDK's own pre-flight
+   * cancellation. Message text is never consulted: a transport failure that
+   * merely mentions an abort is retried, not reported as the user's cancel.
+   */
   private isAbortError(err: unknown): boolean {
-    return err instanceof Error && (
-      err.name === 'AbortError' ||
-      err.message.toLowerCase().includes('abort') ||
-      err.message.toLowerCase().includes('cancelled')
+    return (
+      (err instanceof Error && err.name === 'AbortError') ||
+      (err instanceof SparkVaultMobileError && err.code === 'download_cancelled')
     );
   }