@capgo/capacitor-social-login 8.1.1 → 8.2.1

package/dist/plugin.js

@@ -611,6 +611,449 @@ var capacitorCapacitorUpdater = (function (exports, core) {
         }
     }
 
+    var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    };
+    /**
+     * OAuth2 Social Login Manager
+     * Supports multiple OAuth2 provider configurations
+     */
+    class OAuth2SocialLogin extends BaseSocialLogin {
+        constructor() {
+            super(...arguments);
+            this.providers = new Map();
+            this.TOKENS_KEY_PREFIX = 'capgo_social_login_oauth2_tokens_';
+            this.STATE_PREFIX = 'capgo_social_login_oauth2_state_';
+        }
+        /**
+         * Initialize multiple OAuth2 providers
+         */
+        async initializeProviders(configs) {
+            var _a, _b, _c, _d;
+            for (const [providerId, config] of Object.entries(configs)) {
+                if (!config.appId || !config.authorizationBaseUrl || !config.redirectUrl) {
+                    throw new Error(`OAuth2 provider '${providerId}' requires appId, authorizationBaseUrl, and redirectUrl`);
+                }
+                const internalConfig = Object.assign(Object.assign({}, config), { responseType: (_a = config.responseType) !== null && _a !== void 0 ? _a : 'code', pkceEnabled: (_b = config.pkceEnabled) !== null && _b !== void 0 ? _b : true, scope: (_c = config.scope) !== null && _c !== void 0 ? _c : '', logsEnabled: (_d = config.logsEnabled) !== null && _d !== void 0 ? _d : false });
+                this.providers.set(providerId, internalConfig);
+                if (internalConfig.logsEnabled) {
+                    console.log(`[OAuth2:${providerId}] Initialized with config:`, {
+                        appId: config.appId,
+                        authorizationBaseUrl: config.authorizationBaseUrl,
+                        redirectUrl: config.redirectUrl,
+                        responseType: internalConfig.responseType,
+                        pkceEnabled: internalConfig.pkceEnabled,
+                    });
+                }
+            }
+        }
+        getProvider(providerId) {
+            const config = this.providers.get(providerId);
+            if (!config) {
+                throw new Error(`OAuth2 provider '${providerId}' not configured. Call initialize() first.`);
+            }
+            return config;
+        }
+        getTokensKey(providerId) {
+            return `${this.TOKENS_KEY_PREFIX}${providerId}`;
+        }
+        async login(options) {
+            var _a, _b, _c, _d;
+            const { providerId } = options;
+            const config = this.getProvider(providerId);
+            const redirectUri = (_a = options.redirectUrl) !== null && _a !== void 0 ? _a : config.redirectUrl;
+            const scope = (_b = options.scope) !== null && _b !== void 0 ? _b : config.scope;
+            const state = (_c = options.state) !== null && _c !== void 0 ? _c : this.generateState();
+            const codeVerifier = (_d = options.codeVerifier) !== null && _d !== void 0 ? _d : this.generateCodeVerifier();
+            // Build authorization URL
+            const params = new URLSearchParams({
+                response_type: config.responseType,
+                client_id: config.appId,
+                redirect_uri: redirectUri,
+                state,
+            });
+            if (scope) {
+                params.set('scope', scope);
+            }
+            // Add PKCE for code flow
+            if (config.responseType === 'code' && config.pkceEnabled) {
+                const codeChallenge = await this.generateCodeChallenge(codeVerifier);
+                params.set('code_challenge', codeChallenge);
+                params.set('code_challenge_method', 'S256');
+            }
+            // Add additional parameters from config
+            if (config.additionalParameters) {
+                for (const [key, value] of Object.entries(config.additionalParameters)) {
+                    params.set(key, value);
+                }
+            }
+            // Add additional parameters from login options
+            if (options.additionalParameters) {
+                for (const [key, value] of Object.entries(options.additionalParameters)) {
+                    params.set(key, value);
+                }
+            }
+            // Store pending login state
+            this.persistPendingLogin(state, {
+                providerId,
+                codeVerifier,
+                redirectUri,
+                scope,
+            });
+            localStorage.setItem(BaseSocialLogin.OAUTH_STATE_KEY, JSON.stringify({ provider: 'oauth2', providerId, state }));
+            const authUrl = `${config.authorizationBaseUrl}?${params.toString()}`;
+            if (config.logsEnabled) {
+                console.log(`[OAuth2:${providerId}] Opening authorization URL:`, authUrl);
+            }
+            // Open popup window
+            const width = 500;
+            const height = 650;
+            const left = window.screenX + (window.outerWidth - width) / 2;
+            const top = window.screenY + (window.outerHeight - height) / 2;
+            const popup = window.open(authUrl, 'OAuth2Login', `width=${width},height=${height},left=${left},top=${top},popup=1`);
+            return new Promise((resolve, reject) => {
+                if (!popup) {
+                    reject(new Error('Unable to open login window. Please allow popups.'));
+                    return;
+                }
+                const cleanup = (messageHandler, timeoutHandle, intervalHandle) => {
+                    window.removeEventListener('message', messageHandler);
+                    clearTimeout(timeoutHandle);
+                    clearInterval(intervalHandle);
+                };
+                const messageHandler = (event) => {
+                    var _a, _b, _c, _d, _e;
+                    if (event.origin !== window.location.origin) {
+                        return;
+                    }
+                    if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'oauth-response') {
+                        if (((_b = event.data) === null || _b === void 0 ? void 0 : _b.provider) && event.data.provider !== 'oauth2') {
+                            return;
+                        }
+                        // Check providerId matches if present
+                        if (((_c = event.data) === null || _c === void 0 ? void 0 : _c.providerId) && event.data.providerId !== providerId) {
+                            return;
+                        }
+                        cleanup(messageHandler, timeoutHandle, popupClosedInterval);
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        const _f = event.data, { provider: _ignoredProvider, type: _ignoredType } = _f, payload = __rest$1(_f, ["provider", "type"]);
+                        resolve({
+                            provider: 'oauth2',
+                            result: payload,
+                        });
+                    }
+                    else if (((_d = event.data) === null || _d === void 0 ? void 0 : _d.type) === 'oauth-error') {
+                        if (((_e = event.data) === null || _e === void 0 ? void 0 : _e.provider) && event.data.provider !== 'oauth2') {
+                            return;
+                        }
+                        cleanup(messageHandler, timeoutHandle, popupClosedInterval);
+                        reject(new Error(event.data.error || 'OAuth2 login was cancelled.'));
+                    }
+                };
+                window.addEventListener('message', messageHandler);
+                const timeoutHandle = window.setTimeout(() => {
+                    window.removeEventListener('message', messageHandler);
+                    popup.close();
+                    reject(new Error('OAuth2 login timed out.'));
+                }, 300000);
+                const popupClosedInterval = window.setInterval(() => {
+                    if (popup.closed) {
+                        window.removeEventListener('message', messageHandler);
+                        clearInterval(popupClosedInterval);
+                        clearTimeout(timeoutHandle);
+                        reject(new Error('OAuth2 login window was closed.'));
+                    }
+                }, 1000);
+            });
+        }
+        async logout(providerId) {
+            const config = this.providers.get(providerId);
+            localStorage.removeItem(this.getTokensKey(providerId));
+            // If logout URL is configured, redirect to it
+            if (config === null || config === void 0 ? void 0 : config.logoutUrl) {
+                window.open(config.logoutUrl, '_blank');
+            }
+        }
+        async isLoggedIn(providerId) {
+            const tokens = this.getStoredTokens(providerId);
+            if (!tokens) {
+                return { isLoggedIn: false };
+            }
+            const isValid = tokens.expiresAt > Date.now();
+            if (!isValid) {
+                localStorage.removeItem(this.getTokensKey(providerId));
+            }
+            return { isLoggedIn: isValid };
+        }
+        async getAuthorizationCode(providerId) {
+            const tokens = this.getStoredTokens(providerId);
+            if (!tokens) {
+                throw new Error(`OAuth2 access token is not available for provider '${providerId}'.`);
+            }
+            return {
+                accessToken: tokens.accessToken,
+                jwt: tokens.idToken,
+            };
+        }
+        async refresh(providerId) {
+            const tokens = this.getStoredTokens(providerId);
+            if (!(tokens === null || tokens === void 0 ? void 0 : tokens.refreshToken)) {
+                throw new Error(`No OAuth2 refresh token is available for provider '${providerId}'. Include offline_access scope to receive one.`);
+            }
+            const config = this.getProvider(providerId);
+            if (!config.accessTokenEndpoint) {
+                throw new Error(`No accessTokenEndpoint configured for provider '${providerId}'.`);
+            }
+            await this.refreshWithRefreshToken(providerId, tokens.refreshToken);
+        }
+        async handleOAuthRedirect(url, expectedState) {
+            var _a, _b, _c, _d, _e;
+            // Check both query params and hash fragment
+            const params = new URLSearchParams(url.search);
+            const hashParams = new URLSearchParams(url.hash.slice(1));
+            // Merge params, hash takes priority (for implicit flow)
+            hashParams.forEach((value, key) => {
+                params.set(key, value);
+            });
+            const stateFromUrl = expectedState !== null && expectedState !== void 0 ? expectedState : params.get('state');
+            if (!stateFromUrl) {
+                return null;
+            }
+            const pending = this.consumePendingLogin(stateFromUrl);
+            if (!pending) {
+                localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+                return { error: 'OAuth2 login session expired or state mismatch.' };
+            }
+            const { providerId } = pending;
+            const config = this.providers.get(providerId);
+            if (!config) {
+                localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+                return { error: `OAuth2 provider '${providerId}' configuration not found.` };
+            }
+            const error = params.get('error');
+            if (error) {
+                localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+                return { error: params.get('error_description') || error };
+            }
+            try {
+                let tokenResponse;
+                // Check response type
+                if (params.has('code')) {
+                    // Authorization code flow
+                    const code = params.get('code');
+                    if (!code) {
+                        localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+                        return { error: 'OAuth2 authorization code missing from redirect.' };
+                    }
+                    tokenResponse = await this.exchangeAuthorizationCode(providerId, code, pending);
+                }
+                else if (params.has('access_token')) {
+                    // Implicit flow
+                    tokenResponse = {
+                        access_token: params.get('access_token'),
+                        token_type: params.get('token_type') || 'bearer',
+                        expires_in: params.has('expires_in') ? parseInt(params.get('expires_in'), 10) : undefined,
+                        scope: params.get('scope') || undefined,
+                        id_token: params.get('id_token') || undefined,
+                    };
+                }
+                else {
+                    localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+                    return { error: 'No authorization code or access token in redirect.' };
+                }
+                const expiresAt = tokenResponse.expires_in ? Date.now() + tokenResponse.expires_in * 1000 : Date.now() + 3600000;
+                const scopeArray = (_b = (_a = tokenResponse.scope) === null || _a === void 0 ? void 0 : _a.split(' ').filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+                // Fetch resource data if configured
+                let resourceData = null;
+                if (config.resourceUrl) {
+                    resourceData = await this.fetchResource(providerId, tokenResponse.access_token);
+                }
+                this.persistTokens(providerId, {
+                    accessToken: tokenResponse.access_token,
+                    refreshToken: tokenResponse.refresh_token,
+                    idToken: tokenResponse.id_token,
+                    expiresAt,
+                    scope: scopeArray,
+                    tokenType: tokenResponse.token_type,
+                });
+                return {
+                    provider: 'oauth2',
+                    result: {
+                        providerId,
+                        accessToken: {
+                            token: tokenResponse.access_token,
+                            tokenType: tokenResponse.token_type,
+                            expires: new Date(expiresAt).toISOString(),
+                            refreshToken: tokenResponse.refresh_token,
+                        },
+                        idToken: (_c = tokenResponse.id_token) !== null && _c !== void 0 ? _c : null,
+                        refreshToken: (_d = tokenResponse.refresh_token) !== null && _d !== void 0 ? _d : null,
+                        resourceData,
+                        scope: scopeArray,
+                        tokenType: tokenResponse.token_type,
+                        expiresIn: (_e = tokenResponse.expires_in) !== null && _e !== void 0 ? _e : null,
+                    },
+                };
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    return { error: err.message };
+                }
+                return { error: 'OAuth2 login failed unexpectedly.' };
+            }
+            finally {
+                localStorage.removeItem(BaseSocialLogin.OAUTH_STATE_KEY);
+            }
+        }
+        async exchangeAuthorizationCode(providerId, code, pending) {
+            const config = this.getProvider(providerId);
+            if (!config.accessTokenEndpoint) {
+                throw new Error(`No accessTokenEndpoint configured for provider '${providerId}'.`);
+            }
+            const params = new URLSearchParams({
+                grant_type: 'authorization_code',
+                client_id: config.appId,
+                code,
+                redirect_uri: pending.redirectUri,
+            });
+            if (config.pkceEnabled) {
+                params.set('code_verifier', pending.codeVerifier);
+            }
+            if (config.logsEnabled) {
+                console.log(`[OAuth2:${providerId}] Exchanging code at:`, config.accessTokenEndpoint);
+            }
+            const response = await fetch(config.accessTokenEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: params.toString(),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`OAuth2 token exchange failed (${response.status}): ${text}`);
+            }
+            return (await response.json());
+        }
+        async refreshWithRefreshToken(providerId, refreshToken) {
+            var _a, _b, _c;
+            const config = this.getProvider(providerId);
+            if (!config.accessTokenEndpoint) {
+                throw new Error(`No accessTokenEndpoint configured for provider '${providerId}'.`);
+            }
+            const params = new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: refreshToken,
+                client_id: config.appId,
+            });
+            const response = await fetch(config.accessTokenEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: params.toString(),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`OAuth2 refresh failed (${response.status}): ${text}`);
+            }
+            const tokens = (await response.json());
+            const expiresAt = tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : Date.now() + 3600000;
+            const scopeArray = (_b = (_a = tokens.scope) === null || _a === void 0 ? void 0 : _a.split(' ').filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+            this.persistTokens(providerId, {
+                accessToken: tokens.access_token,
+                refreshToken: (_c = tokens.refresh_token) !== null && _c !== void 0 ? _c : refreshToken,
+                idToken: tokens.id_token,
+                expiresAt,
+                scope: scopeArray,
+                tokenType: tokens.token_type,
+            });
+        }
+        async fetchResource(providerId, accessToken) {
+            const config = this.getProvider(providerId);
+            if (!config.resourceUrl) {
+                throw new Error(`No resourceUrl configured for provider '${providerId}'.`);
+            }
+            const headers = {
+                Authorization: `Bearer ${accessToken}`,
+            };
+            if (config.additionalResourceHeaders) {
+                Object.assign(headers, config.additionalResourceHeaders);
+            }
+            const response = await fetch(config.resourceUrl, {
+                headers,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`Unable to fetch OAuth2 resource (${response.status}): ${text}`);
+            }
+            return (await response.json());
+        }
+        persistTokens(providerId, tokens) {
+            localStorage.setItem(this.getTokensKey(providerId), JSON.stringify(tokens));
+        }
+        getStoredTokens(providerId) {
+            const raw = localStorage.getItem(this.getTokensKey(providerId));
+            if (!raw) {
+                return null;
+            }
+            try {
+                return JSON.parse(raw);
+            }
+            catch (err) {
+                console.warn(`Failed to parse stored OAuth2 tokens for provider '${providerId}'`, err);
+                return null;
+            }
+        }
+        persistPendingLogin(state, payload) {
+            localStorage.setItem(`${this.STATE_PREFIX}${state}`, JSON.stringify(payload));
+        }
+        consumePendingLogin(state) {
+            const key = `${this.STATE_PREFIX}${state}`;
+            const raw = localStorage.getItem(key);
+            localStorage.removeItem(key);
+            if (!raw) {
+                return null;
+            }
+            try {
+                return JSON.parse(raw);
+            }
+            catch (err) {
+                console.warn('Failed to parse pending OAuth2 login payload', err);
+                return null;
+            }
+        }
+        generateState() {
+            return [...crypto.getRandomValues(new Uint8Array(16))].map((b) => b.toString(16).padStart(2, '0')).join('');
+        }
+        generateCodeVerifier() {
+            const array = new Uint8Array(64);
+            crypto.getRandomValues(array);
+            return Array.from(array)
+                .map((b) => 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~'[b % 66])
+                .join('');
+        }
+        async generateCodeChallenge(codeVerifier) {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(codeVerifier);
+            const digest = await crypto.subtle.digest('SHA-256', data);
+            return this.base64UrlEncode(new Uint8Array(digest));
+        }
+        base64UrlEncode(buffer) {
+            let binary = '';
+            buffer.forEach((b) => (binary += String.fromCharCode(b)));
+            return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+        }
+    }
+
     var __rest = (undefined && undefined.__rest) || function (s, e) {
         var t = {};
         for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -964,6 +1407,7 @@ var capacitorCapacitorUpdater = (function (exports, core) {
             this.appleProvider = new AppleSocialLogin();
             this.facebookProvider = new FacebookSocialLogin();
             this.twitterProvider = new TwitterSocialLogin();
+            this.oauth2Provider = new OAuth2SocialLogin();
             // Set up listener for OAuth redirects if we have a pending OAuth flow
             if (localStorage.getItem(SocialLoginWeb.OAUTH_STATE_KEY)) {
                 console.log('OAUTH_STATE_KEY found');
@@ -994,6 +1438,9 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                 case 'twitter':
                     result = await this.twitterProvider.handleOAuthRedirect(url, state);
                     break;
+                case 'oauth2':
+                    result = await this.oauth2Provider.handleOAuthRedirect(url, state);
+                    break;
                 case 'google':
                 default:
                     result = this.googleProvider.handleOAuthRedirect(url);
@@ -1030,6 +1477,9 @@ var capacitorCapacitorUpdater = (function (exports, core) {
             if ((_d = options.twitter) === null || _d === void 0 ? void 0 : _d.clientId) {
                 initPromises.push(this.twitterProvider.initialize(options.twitter.clientId, options.twitter.redirectUrl, options.twitter.defaultScopes, options.twitter.forceLogin, options.twitter.audience));
             }
+            if (options.oauth2 && Object.keys(options.oauth2).length > 0) {
+                initPromises.push(this.oauth2Provider.initializeProviders(options.oauth2));
+            }
             await Promise.all(initPromises);
         }
         async login(options) {
@@ -1042,6 +1492,8 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                     return this.facebookProvider.login(options.options);
                 case 'twitter':
                     return this.twitterProvider.login(options.options);
+                case 'oauth2':
+                    return this.oauth2Provider.login(options.options);
                 default:
                     throw new Error(`Login for ${options.provider} is not implemented on web`);
             }
@@ -1056,6 +1508,11 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                     return this.facebookProvider.logout();
                 case 'twitter':
                     return this.twitterProvider.logout();
+                case 'oauth2':
+                    if (!options.providerId) {
+                        throw new Error('providerId is required for oauth2 logout');
+                    }
+                    return this.oauth2Provider.logout(options.providerId);
                 default:
                     throw new Error(`Logout for ${options.provider} is not implemented`);
             }
@@ -1070,6 +1527,11 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                     return this.facebookProvider.isLoggedIn();
                 case 'twitter':
                     return this.twitterProvider.isLoggedIn();
+                case 'oauth2':
+                    if (!options.providerId) {
+                        throw new Error('providerId is required for oauth2 isLoggedIn');
+                    }
+                    return this.oauth2Provider.isLoggedIn(options.providerId);
                 default:
                     throw new Error(`isLoggedIn for ${options.provider} is not implemented`);
             }
@@ -1084,6 +1546,11 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                     return this.facebookProvider.getAuthorizationCode();
                 case 'twitter':
                     return this.twitterProvider.getAuthorizationCode();
+                case 'oauth2':
+                    if (!options.providerId) {
+                        throw new Error('providerId is required for oauth2 getAuthorizationCode');
+                    }
+                    return this.oauth2Provider.getAuthorizationCode(options.providerId);
                 default:
                     throw new Error(`getAuthorizationCode for ${options.provider} is not implemented`);
             }
@@ -1098,6 +1565,13 @@ var capacitorCapacitorUpdater = (function (exports, core) {
                     return this.facebookProvider.refresh(options.options);
                 case 'twitter':
                     return this.twitterProvider.refresh();
+                case 'oauth2': {
+                    const oauth2Options = options.options;
+                    if (!(oauth2Options === null || oauth2Options === void 0 ? void 0 : oauth2Options.providerId)) {
+                        throw new Error('providerId is required for oauth2 refresh');
+                    }
+                    return this.oauth2Provider.refresh(oauth2Options.providerId);
+                }
                 default:
                     throw new Error(`Refresh for ${options.provider} is not implemented`);
             }