@firebase/auth 1.7.9 → 1.8.0

package/dist/web-extension-cjs/{register-674a8250.js → register-17c71bd5.js}

@@ -993,6 +993,16 @@ class RecaptchaConfig {
             "ENFORCE" /* EnforcementState.ENFORCE */ ||
             this.getProviderEnforcementState(providerStr) === "AUDIT" /* EnforcementState.AUDIT */);
     }
+    /**
+     * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise
+     * returns false.
+     *
+     * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.
+     */
+    isAnyProviderEnabled() {
+        return (this.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */) ||
+            this.isProviderEnabled("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */));
+    }
 }
 
 /**
@@ -3080,6 +3090,167 @@ function _generateCallbackName(prefix) {
     return `__${prefix}${Math.floor(Math.random() * 1000000)}`;
 }
 
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _SOLVE_TIME_MS = 500;
+const _EXPIRATION_TIME_MS = 60000;
+const _WIDGET_ID_START = 1000000000000;
+class MockReCaptcha {
+    constructor(auth) {
+        this.auth = auth;
+        this.counter = _WIDGET_ID_START;
+        this._widgets = new Map();
+    }
+    render(container, parameters) {
+        const id = this.counter;
+        this._widgets.set(id, new MockWidget(container, this.auth.name, parameters || {}));
+        this.counter++;
+        return id;
+    }
+    reset(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.delete());
+        this._widgets.delete(id);
+    }
+    getResponse(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        return ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.getResponse()) || '';
+    }
+    async execute(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.execute());
+        return '';
+    }
+}
+class MockGreCAPTCHATopLevel {
+    constructor() {
+        this.enterprise = new MockGreCAPTCHA();
+    }
+    ready(callback) {
+        callback();
+    }
+    execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _siteKey, _options) {
+        return Promise.resolve('token');
+    }
+    render(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _container, _parameters) {
+        return '';
+    }
+}
+class MockGreCAPTCHA {
+    ready(callback) {
+        callback();
+    }
+    execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _siteKey, _options) {
+        return Promise.resolve('token');
+    }
+    render(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _container, _parameters) {
+        return '';
+    }
+}
+class MockWidget {
+    constructor(containerOrId, appName, params) {
+        this.params = params;
+        this.timerId = null;
+        this.deleted = false;
+        this.responseToken = null;
+        this.clickHandler = () => {
+            this.execute();
+        };
+        const container = typeof containerOrId === 'string'
+            ? document.getElementById(containerOrId)
+            : containerOrId;
+        _assert(container, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, { appName });
+        this.container = container;
+        this.isVisible = this.params.size !== 'invisible';
+        if (this.isVisible) {
+            this.execute();
+        }
+        else {
+            this.container.addEventListener('click', this.clickHandler);
+        }
+    }
+    getResponse() {
+        this.checkIfDeleted();
+        return this.responseToken;
+    }
+    delete() {
+        this.checkIfDeleted();
+        this.deleted = true;
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+        this.container.removeEventListener('click', this.clickHandler);
+    }
+    execute() {
+        this.checkIfDeleted();
+        if (this.timerId) {
+            return;
+        }
+        this.timerId = window.setTimeout(() => {
+            this.responseToken = generateRandomAlphaNumericString(50);
+            const { callback, 'expired-callback': expiredCallback } = this.params;
+            if (callback) {
+                try {
+                    callback(this.responseToken);
+                }
+                catch (e) { }
+            }
+            this.timerId = window.setTimeout(() => {
+                this.timerId = null;
+                this.responseToken = null;
+                if (expiredCallback) {
+                    try {
+                        expiredCallback();
+                    }
+                    catch (e) { }
+                }
+                if (this.isVisible) {
+                    this.execute();
+                }
+            }, _EXPIRATION_TIME_MS);
+        }, _SOLVE_TIME_MS);
+    }
+    checkIfDeleted() {
+        if (this.deleted) {
+            throw new Error('reCAPTCHA mock was already deleted!');
+        }
+    }
+}
+function generateRandomAlphaNumericString(len) {
+    const chars = [];
+    const allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    for (let i = 0; i < len; i++) {
+        chars.push(allowedChars.charAt(Math.floor(Math.random() * allowedChars.length)));
+    }
+    return chars.join('');
+}
+
 /* eslint-disable @typescript-eslint/no-require-imports */
 const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = 'recaptcha-enterprise';
 const FAKE_TOKEN = 'NO_RECAPTCHA';
@@ -3155,6 +3326,11 @@ class RecaptchaEnterpriseVerifier {
                 reject(Error('No reCAPTCHA enterprise script loaded.'));
             }
         }
+        // Returns Promise for a mock token when appVerificationDisabledForTesting is true.
+        if (this.auth.settings.appVerificationDisabledForTesting) {
+            const mockRecaptcha = new MockGreCAPTCHATopLevel();
+            return mockRecaptcha.execute('siteKey', { action: 'verify' });
+        }
         return new Promise((resolve, reject) => {
             retrieveSiteKey(this.auth)
                 .then(siteKey => {
@@ -3185,17 +3361,50 @@ class RecaptchaEnterpriseVerifier {
         });
     }
 }
-async function injectRecaptchaFields(auth, request, action, captchaResp = false) {
+async function injectRecaptchaFields(auth, request, action, isCaptchaResp = false, isFakeToken = false) {
     const verifier = new RecaptchaEnterpriseVerifier(auth);
     let captchaResponse;
-    try {
-        captchaResponse = await verifier.verify(action);
+    if (isFakeToken) {
+        captchaResponse = FAKE_TOKEN;
     }
-    catch (error) {
-        captchaResponse = await verifier.verify(action, true);
+    else {
+        try {
+            captchaResponse = await verifier.verify(action);
+        }
+        catch (error) {
+            captchaResponse = await verifier.verify(action, true);
+        }
     }
     const newRequest = Object.assign({}, request);
-    if (!captchaResp) {
+    if (action === "mfaSmsEnrollment" /* RecaptchaActionName.MFA_SMS_ENROLLMENT */ ||
+        action === "mfaSmsSignIn" /* RecaptchaActionName.MFA_SMS_SIGNIN */) {
+        if ('phoneEnrollmentInfo' in newRequest) {
+            const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
+            const recaptchaToken = newRequest.phoneEnrollmentInfo.recaptchaToken;
+            Object.assign(newRequest, {
+                'phoneEnrollmentInfo': {
+                    phoneNumber,
+                    recaptchaToken,
+                    captchaResponse,
+                    'clientType': "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */,
+                    'recaptchaVersion': "RECAPTCHA_ENTERPRISE" /* RecaptchaVersion.ENTERPRISE */
+                }
+            });
+        }
+        else if ('phoneSignInInfo' in newRequest) {
+            const recaptchaToken = newRequest.phoneSignInInfo.recaptchaToken;
+            Object.assign(newRequest, {
+                'phoneSignInInfo': {
+                    recaptchaToken,
+                    captchaResponse,
+                    'clientType': "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */,
+                    'recaptchaVersion': "RECAPTCHA_ENTERPRISE" /* RecaptchaVersion.ENTERPRISE */
+                }
+            });
+        }
+        return newRequest;
+    }
+    if (!isCaptchaResp) {
         Object.assign(newRequest, { captchaResponse });
     }
     else {
@@ -3207,24 +3416,64 @@ async function injectRecaptchaFields(auth, request, action, captchaResp = false)
     });
     return newRequest;
 }
-async function handleRecaptchaFlow(authInstance, request, actionName, actionMethod) {
-    var _a;
-    if ((_a = authInstance
-        ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaProvider.EMAIL_PASSWORD_PROVIDER */)) {
-        const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
-        return actionMethod(authInstance, requestWithRecaptcha);
+async function handleRecaptchaFlow(authInstance, request, actionName, actionMethod, recaptchaAuthProvider) {
+    var _a, _b;
+    if (recaptchaAuthProvider === "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */) {
+        if ((_a = authInstance
+            ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */)) {
+            const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
+            return actionMethod(authInstance, requestWithRecaptcha);
+        }
+        else {
+            return actionMethod(authInstance, request).catch(async (error) => {
+                if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}`) {
+                    console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
+                    const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
+                    return actionMethod(authInstance, requestWithRecaptcha);
+                }
+                else {
+                    return Promise.reject(error);
+                }
+            });
+        }
     }
-    else {
-        return actionMethod(authInstance, request).catch(async (error) => {
-            if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}`) {
-                console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
-                const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
-                return actionMethod(authInstance, requestWithRecaptcha);
-            }
-            else {
+    else if (recaptchaAuthProvider === "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */) {
+        if ((_b = authInstance
+            ._getRecaptchaConfig()) === null || _b === void 0 ? void 0 : _b.isProviderEnabled("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */)) {
+            const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName);
+            return actionMethod(authInstance, requestWithRecaptcha).catch(async (error) => {
+                var _a;
+                if (((_a = authInstance
+                    ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.getProviderEnforcementState("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */)) === "AUDIT" /* EnforcementState.AUDIT */) {
+                    // AUDIT mode
+                    if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}` ||
+                        error.code === `auth/${"invalid-app-credential" /* AuthErrorCode.INVALID_APP_CREDENTIAL */}`) {
+                        console.log(`Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`);
+                        // reCAPTCHA Enterprise token is missing or reCAPTCHA Enterprise token
+                        // check fails.
+                        // Fallback to reCAPTCHA v2 flow.
+                        const requestWithRecaptchaFields = await injectRecaptchaFields(authInstance, request, actionName, false, // isCaptchaResp
+                        true // isFakeToken
+                        );
+                        // This will call the PhoneApiCaller to fetch and inject reCAPTCHA v2 token.
+                        return actionMethod(authInstance, requestWithRecaptchaFields);
+                    }
+                }
+                // ENFORCE mode or AUDIT mode with any other error.
                 return Promise.reject(error);
-            }
-        });
+            });
+        }
+        else {
+            // Do reCAPTCHA v2 flow.
+            const requestWithRecaptchaFields = await injectRecaptchaFields(authInstance, request, actionName, false, // isCaptchaResp
+            true // isFakeToken
+            );
+            // This will call the PhoneApiCaller to fetch and inject v2 token.
+            return actionMethod(authInstance, requestWithRecaptchaFields);
+        }
+    }
+    else {
+        return Promise.reject(recaptchaAuthProvider + ' provider is not supported.');
     }
 }
 async function _initializeRecaptchaConfig(auth) {
@@ -3240,7 +3489,7 @@ async function _initializeRecaptchaConfig(auth) {
     else {
         authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;
     }
-    if (config.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaProvider.EMAIL_PASSWORD_PROVIDER */)) {
+    if (config.isAnyProviderEnabled()) {
         const verifier = new RecaptchaEnterpriseVerifier(authInternal);
         void verifier.verify();
     }
@@ -3666,7 +3915,7 @@ class EmailAuthCredential extends AuthCredential {
                     password: this._password,
                     clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
                 };
-                return handleRecaptchaFlow(auth, request, "signInWithPassword" /* RecaptchaActionName.SIGN_IN_WITH_PASSWORD */, signInWithPassword);
+                return handleRecaptchaFlow(auth, request, "signInWithPassword" /* RecaptchaActionName.SIGN_IN_WITH_PASSWORD */, signInWithPassword, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
             case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLink$1(auth, {
                     email: this._email,
@@ -3687,7 +3936,7 @@ class EmailAuthCredential extends AuthCredential {
                     password: this._password,
                     clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
                 };
-                return handleRecaptchaFlow(auth, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, linkEmailPassword);
+                return handleRecaptchaFlow(auth, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, linkEmailPassword, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
             case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLinkForLinking(auth, {
                     idToken,
@@ -5682,7 +5931,7 @@ async function sendPasswordResetEmail(auth, email, actionCodeSettings) {
     if (actionCodeSettings) {
         _setActionCodeSettingsOnRequest(authInternal, request, actionCodeSettings);
     }
-    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendPasswordResetEmail$1);
+    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendPasswordResetEmail$1, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
 }
 /**
  * Completes the password reset process, given a confirmation code and new password.
@@ -5815,7 +6064,7 @@ async function createUserWithEmailAndPassword(auth, email, password) {
         password,
         clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
     };
-    const signUpResponse = handleRecaptchaFlow(authInternal, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, signUp);
+    const signUpResponse = handleRecaptchaFlow(authInternal, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, signUp, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
     const response = await signUpResponse.catch(error => {
         if (error.code === `auth/${"password-does-not-meet-requirements" /* AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */}`) {
             void recachePasswordPolicy(auth);
@@ -5929,7 +6178,7 @@ async function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
         }
     }
     setActionCodeSettings(request, actionCodeSettings);
-    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendSignInLinkToEmail$1);
+    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendSignInLinkToEmail$1, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
 }
 /**
  * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.
@@ -7755,7 +8004,7 @@ function _isEmptyString(input) {
 }
 
 var name = "@firebase/auth";
-var version = "1.7.9";
+var version = "1.8.0";
 
 /**
  * @license
@@ -7897,7 +8146,7 @@ function registerAuth(clientPlatform) {
         return (auth => new AuthInterop(auth))(auth);
     }, "PRIVATE" /* ComponentType.PRIVATE */).setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */));
     app.registerVersion(name, version, getVersionForPlatform(clientPlatform));
-    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation
     app.registerVersion(name, version, 'cjs2017');
 }
 
@@ -7909,11 +8158,13 @@ exports.BaseOAuthProvider = BaseOAuthProvider;
 exports.Delay = Delay;
 exports.EmailAuthCredential = EmailAuthCredential;
 exports.EmailAuthProvider = EmailAuthProvider;
+exports.FAKE_TOKEN = FAKE_TOKEN;
 exports.FacebookAuthProvider = FacebookAuthProvider;
 exports.FederatedAuthProvider = FederatedAuthProvider;
 exports.FetchProvider = FetchProvider;
 exports.GithubAuthProvider = GithubAuthProvider;
 exports.GoogleAuthProvider = GoogleAuthProvider;
+exports.MockReCaptcha = MockReCaptcha;
 exports.MultiFactorAssertionImpl = MultiFactorAssertionImpl;
 exports.OAuthCredential = OAuthCredential;
 exports.OAuthProvider = OAuthProvider;
@@ -7938,6 +8189,7 @@ exports._generateEventId = _generateEventId;
 exports._getClientVersion = _getClientVersion;
 exports._getCurrentUrl = _getCurrentUrl;
 exports._getInstance = _getInstance;
+exports._initializeRecaptchaConfig = _initializeRecaptchaConfig;
 exports._isAndroid = _isAndroid;
 exports._isChromeIOS = _isChromeIOS;
 exports._isFirefox = _isFirefox;
@@ -7977,6 +8229,7 @@ exports.getIdToken = getIdToken;
 exports.getIdTokenResult = getIdTokenResult;
 exports.getMultiFactorResolver = getMultiFactorResolver;
 exports.getRecaptchaParams = getRecaptchaParams;
+exports.handleRecaptchaFlow = handleRecaptchaFlow;
 exports.inMemoryPersistence = inMemoryPersistence;
 exports.indexedDBLocalPersistence = indexedDBLocalPersistence;
 exports.initializeAuth = initializeAuth;
@@ -8016,4 +8269,4 @@ exports.useDeviceLanguage = useDeviceLanguage;
 exports.validatePassword = validatePassword;
 exports.verifyBeforeUpdateEmail = verifyBeforeUpdateEmail;
 exports.verifyPasswordResetCode = verifyPasswordResetCode;
-//# sourceMappingURL=register-674a8250.js.map
+//# sourceMappingURL=register-17c71bd5.js.map