@proveanything/smartlinks-auth-ui 0.5.9 → 0.5.11

package/dist/index.js

@@ -3,7 +3,6 @@
 var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
 var smartlinks = require('@proveanything/smartlinks');
-var http = require('@proveanything/smartlinks/dist/http');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -3117,24 +3116,25 @@ function isPossiblePhoneNumber(input, options, metadata) {
     }
   }
 
-  // Old metadata (< 1.0.18) had no "possible length" data.
+  // Old (legacy) metadata (< 1.0.18) had no "possible length" data.
+  // So `isPossibleNumber()` function is supported only for non-legacy metadata.
   if (metadata.possibleLengths()) {
     return isPossibleNumber(input.phone || input.nationalNumber, input.country, metadata);
-  } else {
-    // There was a bug between `1.7.35` and `1.7.37` where "possible_lengths"
-    // were missing for "non-geographical" numbering plans.
-    // Just assume the number is possible in such cases:
-    // it's unlikely that anyone generated their custom metadata
-    // in that short period of time (one day).
-    // This code can be removed in some future major version update.
-    if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {
-      // "Non-geographic entities" did't have `possibleLengths`
-      // due to a bug in metadata generation process.
-      return true;
-    } else {
-      throw new Error('Missing "possibleLengths" in metadata. Perhaps the metadata has been generated before v1.0.18.');
-    }
   }
+
+  // There was a bug in versions from `1.7.35` to `1.7.37` of `libphonenumber-js`
+  // where "possible_lengths" property was missing from "non-geographical" numbering plans' metadata.
+  // After that, the bug was noticed and fixed.
+  // So for versions from `1.7.35` to `1.7.37`, just assume that all "non=geotraphical" numbers are possible.
+  // The reason is that the bug was noticed relatively quickly (within a day or so)
+  // and it's unlikely that anyone generated their custom metadata in that short time span.
+  // And if they didn't generate any custom metadata then a follow-up package update would've silently fixed the bug.
+  if (input.countryCallingCode && metadata.isNonGeographicCallingCode(input.countryCallingCode)) {
+    return true;
+  }
+
+  // `isPossibleNumber()` function is not supported.
+  throw new Error('Missing "possibleLengths" in metadata. Perhaps the metadata has been generated before v1.0.18.');
 }
 function isPossibleNumber(nationalNumber, country, metadata) {
   //, isInternational) {
@@ -11375,7 +11375,7 @@ class AuthAPI {
         });
         // Exchange authorization code for tokens via backend
         // Use direct HTTP call since SDK may not have this method in authKit namespace yet
-        return http.post(`/authkit/${this.clientId}/google-code`, {
+        return smartlinks.post(`/authkit/${this.clientId}/google-code`, {
             code,
             redirectUri,
         });
@@ -12056,6 +12056,7 @@ collectionId, enableContactSync, enableInteractionTracking, interactionAppId, in
     const callbacksRef = React.useRef(new Set());
     const initializingRef = React.useRef(false);
     const pendingVerificationRef = React.useRef(false);
+    const proxyRefreshInFlightRef = React.useRef(false);
     // Stable refs for callbacks to avoid useEffect dependency cycles
     const syncContactRef = React.useRef();
     const trackInteractionRef = React.useRef();
@@ -12253,9 +12254,9 @@ collectionId, enableContactSync, enableInteractionTracking, interactionAppId, in
             try {
                 if (proxyMode) {
                     // Check if credentials exist before making the API call
-                    const headers = http.getApiHeaders();
+                    const headers = smartlinks.getApiHeaders();
                     const hasBearer = !!headers['Authorization'];
-                    const hasSdkProxy = http.isProxyEnabled();
+                    const hasSdkProxy = smartlinks.isProxyEnabled();
                     console.log('[AuthContext] 🔍 Proxy mode init:', {
                         hasBearer,
                         hasSdkProxy,
@@ -12417,6 +12418,85 @@ collectionId, enableContactSync, enableInteractionTracking, interactionAppId, in
             window.removeEventListener('message', handleParentMessage);
         };
     }, [proxyMode, notifyAuthStateChange]);
+    // In proxy mode, mobile auth often returns from WhatsApp/Google via app switching,
+    // so the page stays mounted while the parent session changes underneath it.
+    // Re-check account state on focus/visibility/page restore so login/logout appears
+    // immediately instead of waiting for a full refresh.
+    React.useEffect(() => {
+        if (!proxyMode)
+            return;
+        const clearProxyState = () => {
+            setUser(null);
+            setToken(null);
+            setAccountData(null);
+            setAccountInfo(null);
+            setContact(null);
+            setContactId(null);
+            setIsVerified(false);
+            pendingVerificationRef.current = false;
+            notifyAuthStateChange('LOGOUT', null, null, null, null, false);
+        };
+        const refreshProxySession = async () => {
+            if (proxyRefreshInFlightRef.current)
+                return;
+            const headers = smartlinks.getApiHeaders();
+            const hasBearer = !!headers['Authorization'];
+            const hasSdkProxy = smartlinks.isProxyEnabled();
+            if (!hasBearer && !hasSdkProxy) {
+                clearProxyState();
+                return;
+            }
+            proxyRefreshInFlightRef.current = true;
+            try {
+                const accountResponse = await smartlinks__namespace.auth.getAccount();
+                const accountAny = accountResponse;
+                const hasValidSession = accountAny?.uid && accountAny.uid.length > 0;
+                if (!hasValidSession) {
+                    clearProxyState();
+                    return;
+                }
+                const userObj = {
+                    uid: accountAny.uid,
+                    email: accountAny?.email,
+                    displayName: accountAny?.displayName || accountAny?.name,
+                    phoneNumber: accountAny?.phoneNumber,
+                };
+                setUser(userObj);
+                setAccountData(accountResponse);
+                setAccountInfo(accountResponse);
+                setIsVerified(true);
+                pendingVerificationRef.current = false;
+                notifyAuthStateChange('CROSS_TAB_SYNC', userObj, null, accountResponse, accountResponse, true);
+            }
+            catch (error) {
+                if (!isNetworkError(error)) {
+                    clearProxyState();
+                }
+            }
+            finally {
+                proxyRefreshInFlightRef.current = false;
+            }
+        };
+        const handleFocus = () => {
+            refreshProxySession().catch(() => { });
+        };
+        const handlePageShow = () => {
+            refreshProxySession().catch(() => { });
+        };
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                refreshProxySession().catch(() => { });
+            }
+        };
+        window.addEventListener('focus', handleFocus);
+        window.addEventListener('pageshow', handlePageShow);
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            window.removeEventListener('focus', handleFocus);
+            window.removeEventListener('pageshow', handlePageShow);
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        };
+    }, [proxyMode, notifyAuthStateChange, isNetworkError]);
     // Cross-tab synchronization - standalone mode only
     React.useEffect(() => {
         if (proxyMode)
@@ -12898,13 +12978,18 @@ const getActionResultErrorMessage = (result) => {
         details: candidate.details,
     });
 };
+// ----- WhatsApp reply helpers -----
+const WHATSAPP_PENDING_SESSION_KEY = 'whatsapp_pending_session';
 const interpolateReply = (input, vars) => {
     if (!input)
         return input;
     return input
         .replace(/\{\{\s*name\s*\}\}/gi, vars.name?.trim() || 'there')
         .replace(/\{\{\s*clientName\s*\}\}/gi, vars.clientName?.trim() || '')
-        .replace(/\{\{\s*phoneNumber\s*\}\}/gi, vars.phoneNumber?.trim() || '');
+        .replace(/\{\{\s*phoneNumber\s*\}\}/gi, vars.phoneNumber?.trim() || '')
+        .replace(/\{\{\s*returnUrl\s*\}\}/gi, vars.returnUrl?.trim() || '')
+        .replace(/\{\{\s*clientId\s*\}\}/gi, vars.clientId?.trim() || '')
+        .replace(/\{\{\s*token\s*\}\}/gi, vars.token?.trim() || '');
 };
 const buildWhatsAppReply = (cfg, vars) => {
     if (!cfg)
@@ -13230,6 +13315,24 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
         // Get the full current URL including hash routes, strip query params
         return window.location.href.split('?')[0];
     };
+    const savePendingWhatsAppSession = async (session) => {
+        if (proxyMode)
+            return;
+        const storage = await getStorage();
+        await storage.setItem(WHATSAPP_PENDING_SESSION_KEY, session);
+    };
+    const loadPendingWhatsAppSession = async () => {
+        if (proxyMode)
+            return null;
+        const storage = await getStorage();
+        return storage.getItem(WHATSAPP_PENDING_SESSION_KEY);
+    };
+    const clearPendingWhatsAppSession = async () => {
+        if (proxyMode)
+            return;
+        const storage = await getStorage();
+        await storage.removeItem(WHATSAPP_PENDING_SESSION_KEY);
+    };
     // Fetch UI configuration
     React.useEffect(() => {
         // Wait for SDK to be ready before fetching config
@@ -14319,6 +14422,48 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
     };
     // Track the most recent WhatsApp send so we can exchange its sessionKey for a real login session.
     const whatsappSendRef = React.useRef(null);
+    React.useEffect(() => {
+        if (proxyMode)
+            return;
+        let cancelled = false;
+        const resumePendingWhatsAppSession = async () => {
+            try {
+                const pending = await loadPendingWhatsAppSession();
+                if (!pending || cancelled)
+                    return;
+                // Expire stale pending sessions after 30 minutes to avoid resurrecting old attempts.
+                if (Date.now() - pending.createdAt > 30 * 60 * 1000) {
+                    await clearPendingWhatsAppSession();
+                    return;
+                }
+                whatsappSendRef.current = {
+                    token: pending.token,
+                    sessionKey: pending.sessionKey,
+                    displayName: pending.displayName,
+                };
+                const status = await api.getWhatsAppStatus(pending.token);
+                if (cancelled)
+                    return;
+                if (status.verified) {
+                    await handleWhatsAppVerified(status);
+                    return;
+                }
+                if (status.status === 'pending') {
+                    setMode('whatsapp');
+                }
+                else if (status.status === 'failed' || status.status === 'expired' || status.status === 'unknown') {
+                    await clearPendingWhatsAppSession();
+                }
+            }
+            catch (err) {
+                log.warn('Failed to resume pending WhatsApp session:', err);
+            }
+        };
+        resumePendingWhatsAppSession();
+        return () => {
+            cancelled = true;
+        };
+    }, [proxyMode, clientId]);
     const handleWhatsAppSend = async (displayName) => {
         setLoading(true);
         setError(undefined);
@@ -14327,9 +14472,12 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
             // account from the inbound WhatsApp webhook (sender's number is the proof).
             // Resolve reply config: per-call prop wins, otherwise fall back to AuthKit default.
             const replyConfig = whatsappReply ?? config?.whatsappReply;
+            const effectiveRedirectUrl = getRedirectUrl();
             const reply = buildWhatsAppReply(replyConfig, {
                 name: displayName,
                 clientName,
+                returnUrl: effectiveRedirectUrl,
+                clientId,
             });
             // Resolve outbound prefill message: per-call prop wins, then AuthKit default.
             const prefillMessage = whatsappPrefillMessage ?? config?.whatsappPrefillMessage;
@@ -14338,12 +14486,19 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
             // formed session.user — no follow-up updateProfile call needed.
             const trimmedName = displayName?.trim() || undefined;
             const contactData = trimmedName ? { name: trimmedName } : undefined;
-            const result = await api.sendWhatsApp(getRedirectUrl(), undefined, reply, prefillMessage, contactData);
+            const result = await api.sendWhatsApp(effectiveRedirectUrl, undefined, reply, prefillMessage, contactData);
             whatsappSendRef.current = {
                 token: result.token,
                 sessionKey: result.sessionKey,
                 displayName: trimmedName,
             };
+            await savePendingWhatsAppSession({
+                token: result.token,
+                sessionKey: result.sessionKey,
+                displayName: trimmedName,
+                redirectUrl: effectiveRedirectUrl,
+                createdAt: Date.now(),
+            });
             return result;
         }
         catch (err) {
@@ -14374,12 +14529,15 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                     if (!proxyMode) {
                         onAuthSuccess(session.token, session.user, session.accountData);
                     }
+                    await clearPendingWhatsAppSession();
+                    return;
                 }
             }
             catch (err) {
                 log.warn('WhatsApp session exchange failed, falling back to redirect-only flow:', err);
             }
         }
+        await clearPendingWhatsAppSession();
         performRedirect(target, 'magic-link');
     };
     // Show processing state for URL-based auth (verification, magic link, password reset)