@oxyhq/core 1.11.18 → 1.11.20

package/dist/esm/mixins/OxyServices.fedcm.js

@@ -1,6 +1,38 @@
 import { OxyAuthenticationError } from '../OxyServices.errors.js';
 import { createDebugLogger } from '../shared/utils/debugUtils.js';
 const debug = createDebugLogger('FedCM');
+// Modern (W3C spec) → legacy (Chrome 125–131) mode value mapping. Used to
+// retry a credential request when an older browser rejects the modern enum.
+const MODERN_TO_LEGACY_MODE = {
+    active: 'button',
+    passive: 'widget',
+};
+// Legacy → modern mapping so callers may pass either spelling.
+const LEGACY_TO_MODERN_MODE = {
+    button: 'active',
+    widget: 'passive',
+};
+/**
+ * Normalise any accepted mode value to the modern W3C spelling
+ * (`'active'`/`'passive'`), which is what is sent to the browser first.
+ */
+function toModernMode(mode) {
+    return mode === 'button' || mode === 'widget' ? LEGACY_TO_MODERN_MODE[mode] : mode;
+}
+/**
+ * Detect the synchronous `TypeError` a pre-spec browser throws when it does not
+ * recognise a modern `mode` enum value (e.g. Chrome 125–131 rejecting
+ * `'active'`/`'passive'`). Such a browser only understands the legacy
+ * `'button'`/`'widget'` values, so the caller can retry with those.
+ */
+function isUnknownModeEnumError(error) {
+    if (!(error instanceof TypeError))
+        return false;
+    const message = error.message.toLowerCase();
+    return (message.includes('identitycredentialrequestoptionsmode') ||
+        ((message.includes('active') || message.includes('passive')) &&
+            (message.includes('enum') || message.includes('not a valid'))));
+}
 const FEDCM_LOGIN_HINT_KEY = 'oxy_fedcm_login_hint';
 // Global lock to prevent concurrent FedCM requests
 // FedCM only allows one navigator.credentials.get request at a time
@@ -90,15 +122,17 @@ export function OxyServicesFedCMMixin(Base) {
                     // Use provided loginHint, or fall back to stored last-used account ID
                     const loginHint = options.loginHint || this.getStoredLoginHint();
                     debug.log('Interactive sign-in: Requesting credential for', clientId, loginHint ? `(hint: ${loginHint})` : '');
-                    // Request credential from browser's native identity flow
-                    // mode: 'button' signals this is a user-gesture-initiated flow (Chrome 125+)
+                    // Request credential from browser's native identity flow.
+                    // mode: 'active' signals this is a user-gesture-initiated (button) flow.
+                    // 'active' is the current W3C spec value; requestIdentityCredential
+                    // transparently retries with the legacy 'button' value for Chrome 125–131.
                     const credential = await this.requestIdentityCredential({
                         configURL: this.resolveFedcmConfigUrl(),
                         clientId,
                         nonce,
                         context: options.context,
                         loginHint,
-                        mode: 'button',
+                        mode: 'active',
                     });
                     if (!credential || !credential.token) {
                         throw new OxyAuthenticationError('No credential received from browser');
@@ -106,9 +140,11 @@ export function OxyServicesFedCMMixin(Base) {
                     debug.log('Interactive sign-in: Got credential, exchanging for session');
                     // Exchange FedCM ID token for Oxy session
                     const session = await this.exchangeIdTokenForSession(credential.token);
-                    // Store access token in HttpService (extract from response or get from session)
-                    if (session && session.accessToken) {
-                        this.httpService.setTokens(session.accessToken);
+                    // Store access token in HttpService. `accessToken`/`refreshToken` are
+                    // declared optional on SessionLoginResponse; default the refresh token to
+                    // an empty string when the exchange did not return one.
+                    if (session?.accessToken) {
+                        this.httpService.setTokens(session.accessToken, session.refreshToken ?? '');
                     }
                     // Store the user ID as loginHint for future FedCM requests
                     if (session?.user?.id) {
@@ -120,10 +156,13 @@ export function OxyServicesFedCMMixin(Base) {
                 catch (error) {
                     debug.log('Interactive sign-in failed:', error);
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (error.name === 'AbortError') {
+                    // FedCM aborts/network failures surface as DOMException/Error instances,
+                    // both of which carry a `name`. Anything else has no meaningful name.
+                    const errorName = error instanceof Error ? error.name : '';
+                    if (errorName === 'AbortError') {
                         throw new OxyAuthenticationError('Sign-in was cancelled by user');
                     }
-                    if (error.name === 'NetworkError') {
+                    if (errorName === 'NetworkError') {
                         throw new OxyAuthenticationError('Network error during sign-in. Please check your connection.');
                     }
                     if (errorMessage.includes('multiple accounts')) {
@@ -235,9 +274,11 @@ export function OxyServicesFedCMMixin(Base) {
                     debug.error('Silent SSO: Exchange returned session without user:', session);
                     return null;
                 }
-                // Set the access token
+                // Set the access token. `accessToken`/`refreshToken` are declared optional
+                // on SessionLoginResponse; default the refresh token to an empty string when
+                // the exchange did not return one.
                 if (session.accessToken) {
-                    this.httpService.setTokens(session.accessToken);
+                    this.httpService.setTokens(session.accessToken, session.refreshToken ?? '');
                     debug.log('Silent SSO: Access token set');
                 }
                 else {
@@ -306,37 +347,63 @@ export function OxyServicesFedCMMixin(Base) {
                     debug.log('Request timed out after', timeoutMs, 'ms (mediation:', requestedMediation + ')');
                     controller.abort();
                 }, timeoutMs);
+                // Normalise the caller's mode to the modern W3C value first. A modern
+                // browser accepts it; an older one (Chrome 125–131) rejects it with a
+                // synchronous TypeError, in which case we retry with the legacy value.
+                const modernMode = options.mode ? toModernMode(options.mode) : undefined;
+                // Build the identity request for a specific mode value. The `mode` field
+                // lives on the `identity` object (sibling of `providers`), separate from
+                // the top-level `mediation` field.
+                const buildCredentialOptions = (modeValue) => ({
+                    identity: {
+                        providers: [
+                            {
+                                configURL: options.configURL,
+                                clientId: options.clientId,
+                                // Older browsers read `nonce` at the top level; Chrome 145+
+                                // expects it inside `params`. Send both for full coverage.
+                                nonce: options.nonce,
+                                params: {
+                                    nonce: options.nonce,
+                                },
+                                ...(options.loginHint && { loginHint: options.loginHint }),
+                            },
+                        ],
+                        ...(modeValue && { mode: modeValue }),
+                    },
+                    mediation: requestedMediation,
+                    signal: controller.signal,
+                });
+                // The DOM lib's `CredentialsContainer` does not declare the FedCM `identity`
+                // request in every TypeScript version we build against. Re-type through the
+                // minimal structural interface above (not `any`) to keep this typed.
+                const credentials = navigator.credentials;
                 fedCMRequestPromise = (async () => {
                     try {
-                        debug.log('Calling navigator.credentials.get with mediation:', requestedMediation);
-                        // Type assertion needed as FedCM types may not be in all TypeScript versions
-                        const credentialOptions = {
-                            identity: {
-                                providers: [
-                                    {
-                                        configURL: options.configURL,
-                                        clientId: options.clientId,
-                                        // Older browsers read `nonce` at the top level; Chrome 145+
-                                        // expects it inside `params`. Send both for full coverage.
-                                        nonce: options.nonce,
-                                        params: {
-                                            nonce: options.nonce,
-                                        },
-                                        ...(options.loginHint && { loginHint: options.loginHint }),
-                                    },
-                                ],
-                                ...(options.mode && { mode: options.mode }),
-                            },
-                            mediation: requestedMediation,
-                            signal: controller.signal,
-                        };
-                        const credential = (await navigator.credentials.get(credentialOptions));
+                        debug.log('Calling navigator.credentials.get with mediation:', requestedMediation, modernMode ? `mode: ${modernMode}` : '');
+                        let credential;
+                        try {
+                            credential = await credentials.get(buildCredentialOptions(modernMode));
+                        }
+                        catch (modeError) {
+                            // Chrome 125–131 only knows the legacy 'button'/'widget' enum and
+                            // throws a synchronous TypeError for the modern 'active'/'passive'
+                            // values. Retry once with the legacy value so older browsers work.
+                            if (modernMode && isUnknownModeEnumError(modeError)) {
+                                const legacyMode = MODERN_TO_LEGACY_MODE[modernMode];
+                                debug.log(`Browser rejected modern mode '${modernMode}'; retrying with legacy mode '${legacyMode}'`);
+                                credential = await credentials.get(buildCredentialOptions(legacyMode));
+                            }
+                            else {
+                                throw modeError;
+                            }
+                        }
                         debug.log('navigator.credentials.get returned:', {
                             hasCredential: !!credential,
                             type: credential?.type,
                             hasToken: !!credential?.token,
                         });
-                        if (!credential || credential.type !== 'identity') {
+                        if (!credential || credential.type !== 'identity' || !credential.token) {
                             debug.log('No valid identity credential returned');
                             return null;
                         }
@@ -397,9 +464,15 @@ export function OxyServicesFedCMMixin(Base) {
                     return;
                 }
                 try {
-                    if ('IdentityCredential' in window && 'disconnect' in window.IdentityCredential) {
+                    // The DOM lib does not declare the global `IdentityCredential` interface
+                    // object (with its static `disconnect`) in every TypeScript version we
+                    // build against. Read it off `window` through the minimal structural type
+                    // (not `any`), guarding that `disconnect` is actually present at runtime.
+                    const fedCMWindow = window;
+                    const identityCredential = fedCMWindow.IdentityCredential;
+                    if (identityCredential && typeof identityCredential.disconnect === 'function') {
                         const clientId = this.getClientId();
-                        await window.IdentityCredential.disconnect({
+                        await identityCredential.disconnect({
                             configURL: this.resolveFedcmConfigUrl(),
                             clientId,
                             accountHint: accountHint || '*',