@firebase/auth 1.7.9 → 1.8.0

package/dist/web-extension-cjs/internal.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var register = require('./register-674a8250.js');
+var register = require('./register-17c71bd5.js');
 var util = require('@firebase/util');
 var app = require('@firebase/app');
 require('tslib');
@@ -382,134 +382,6 @@ BrowserSessionPersistence.type = 'SESSION';
  */
 const browserSessionPersistence = BrowserSessionPersistence;
 
-/**
- * @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 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;
-        register._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('');
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -607,7 +479,7 @@ function isHostLanguageValid(hl) {
 }
 class MockReCaptchaLoaderImpl {
     async load(auth) {
-        return new MockReCaptcha(auth);
+        return new register.MockReCaptcha(auth);
     }
     clearedOneInstance() { }
 }
@@ -864,12 +736,15 @@ class ConfirmationResultImpl {
  * provides the code sent to their phone, call {@link ConfirmationResult.confirm}
  * with the code to sign the user in.
  *
- * For abuse prevention, this method also requires a {@link ApplicationVerifier}.
- * This SDK includes a reCAPTCHA-based implementation, {@link RecaptchaVerifier}.
+ * For abuse prevention, this method requires a {@link ApplicationVerifier}.
+ * This SDK includes an implementation based on reCAPTCHA v2, {@link RecaptchaVerifier}.
  * This function can work on other platforms that do not support the
  * {@link RecaptchaVerifier} (like React Native), but you need to use a
  * third-party {@link ApplicationVerifier} implementation.
  *
+ * If you've enabled project-level reCAPTCHA Enterprise bot protection in
+ * Enforce mode, you can omit the {@link ApplicationVerifier}.
+ *
  * This method does not work in a Node.js environment or with {@link Auth} instances created with a
  * {@link @firebase/app#FirebaseServerApp}.
  *
@@ -943,10 +818,19 @@ async function reauthenticateWithPhoneNumber(user, phoneNumber, appVerifier) {
  */
 async function _verifyPhoneNumber(auth, options, verifier) {
     var _a;
-    const recaptchaToken = await verifier.verify();
+    if (!auth._getRecaptchaConfig()) {
+        try {
+            await register._initializeRecaptchaConfig(auth);
+        }
+        catch (error) {
+            // If an error occurs while fetching the config, there is no way to know the enablement state
+            // of Phone provider, so we proceed with recaptcha V2 verification.
+            // The error is likely "recaptchaKey undefined", as reCAPTCHA Enterprise is not
+            // enabled for any provider.
+            console.log('Failed to initialize reCAPTCHA Enterprise config. Triggering the reCAPTCHA v2 verification.');
+        }
+    }
     try {
-        register._assert(typeof recaptchaToken === 'string', auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
-        register._assert(verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         let phoneInfoOptions;
         if (typeof options === 'string') {
             phoneInfoOptions = {
@@ -960,12 +844,25 @@ async function _verifyPhoneNumber(auth, options, verifier) {
             const session = phoneInfoOptions.session;
             if ('phoneNumber' in phoneInfoOptions) {
                 register._assert(session.type === "enroll" /* MultiFactorSessionType.ENROLL */, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
-                const response = await register.startEnrollPhoneMfa(auth, {
+                const startPhoneMfaEnrollmentRequest = {
                     idToken: session.credential,
                     phoneEnrollmentInfo: {
                         phoneNumber: phoneInfoOptions.phoneNumber,
-                        recaptchaToken
+                        clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+                    }
+                };
+                const startEnrollPhoneMfaActionCallback = async (authInstance, request) => {
+                    // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                    if (request.phoneEnrollmentInfo.captchaResponse === register.FAKE_TOKEN) {
+                        register._assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                        const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                        return register.startEnrollPhoneMfa(authInstance, requestWithRecaptchaV2);
                     }
+                    return register.startEnrollPhoneMfa(authInstance, request);
+                };
+                const startPhoneMfaEnrollmentResponse = register.handleRecaptchaFlow(auth, startPhoneMfaEnrollmentRequest, "mfaSmsEnrollment" /* RecaptchaActionName.MFA_SMS_ENROLLMENT */, startEnrollPhoneMfaActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+                const response = await startPhoneMfaEnrollmentResponse.catch(error => {
+                    return Promise.reject(error);
                 });
                 return response.phoneSessionInfo.sessionInfo;
             }
@@ -974,26 +871,52 @@ async function _verifyPhoneNumber(auth, options, verifier) {
                 const mfaEnrollmentId = ((_a = phoneInfoOptions.multiFactorHint) === null || _a === void 0 ? void 0 : _a.uid) ||
                     phoneInfoOptions.multiFactorUid;
                 register._assert(mfaEnrollmentId, auth, "missing-multi-factor-info" /* AuthErrorCode.MISSING_MFA_INFO */);
-                const response = await register.startSignInPhoneMfa(auth, {
+                const startPhoneMfaSignInRequest = {
                     mfaPendingCredential: session.credential,
                     mfaEnrollmentId,
                     phoneSignInInfo: {
-                        recaptchaToken
+                        clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+                    }
+                };
+                const startSignInPhoneMfaActionCallback = async (authInstance, request) => {
+                    // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                    if (request.phoneSignInInfo.captchaResponse === register.FAKE_TOKEN) {
+                        register._assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                        const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                        return register.startSignInPhoneMfa(authInstance, requestWithRecaptchaV2);
                     }
+                    return register.startSignInPhoneMfa(authInstance, request);
+                };
+                const startPhoneMfaSignInResponse = register.handleRecaptchaFlow(auth, startPhoneMfaSignInRequest, "mfaSmsSignIn" /* RecaptchaActionName.MFA_SMS_SIGNIN */, startSignInPhoneMfaActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+                const response = await startPhoneMfaSignInResponse.catch(error => {
+                    return Promise.reject(error);
                 });
                 return response.phoneResponseInfo.sessionInfo;
             }
         }
         else {
-            const { sessionInfo } = await register.sendPhoneVerificationCode(auth, {
+            const sendPhoneVerificationCodeRequest = {
                 phoneNumber: phoneInfoOptions.phoneNumber,
-                recaptchaToken
+                clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+            };
+            const sendPhoneVerificationCodeActionCallback = async (authInstance, request) => {
+                // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                if (request.captchaResponse === register.FAKE_TOKEN) {
+                    register._assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                    const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                    return register.sendPhoneVerificationCode(authInstance, requestWithRecaptchaV2);
+                }
+                return register.sendPhoneVerificationCode(authInstance, request);
+            };
+            const sendPhoneVerificationCodeResponse = register.handleRecaptchaFlow(auth, sendPhoneVerificationCodeRequest, "sendVerificationCode" /* RecaptchaActionName.SEND_VERIFICATION_CODE */, sendPhoneVerificationCodeActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+            const response = await sendPhoneVerificationCodeResponse.catch(error => {
+                return Promise.reject(error);
             });
-            return sessionInfo;
+            return response.sessionInfo;
         }
     }
     finally {
-        verifier._reset();
+        verifier === null || verifier === void 0 ? void 0 : verifier._reset();
     }
 }
 /**
@@ -1025,6 +948,49 @@ async function updatePhoneNumber(user, credential) {
         return Promise.reject(register._serverAppCurrentUserOperationNotSupportedError(userInternal.auth));
     }
     await register._link(userInternal, credential);
+}
+// Helper function that fetches and injects a reCAPTCHA v2 token into the request.
+async function injectRecaptchaV2Token(auth, request, recaptchaV2Verifier) {
+    register._assert(recaptchaV2Verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+    const recaptchaV2Token = await recaptchaV2Verifier.verify();
+    register._assert(typeof recaptchaV2Token === 'string', auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+    const newRequest = Object.assign({}, request);
+    if ('phoneEnrollmentInfo' in newRequest) {
+        const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
+        const captchaResponse = newRequest.phoneEnrollmentInfo.captchaResponse;
+        const clientType = newRequest
+            .phoneEnrollmentInfo.clientType;
+        const recaptchaVersion = newRequest.phoneEnrollmentInfo.recaptchaVersion;
+        Object.assign(newRequest, {
+            'phoneEnrollmentInfo': {
+                phoneNumber,
+                recaptchaToken: recaptchaV2Token,
+                captchaResponse,
+                clientType,
+                recaptchaVersion
+            }
+        });
+        return newRequest;
+    }
+    else if ('phoneSignInInfo' in newRequest) {
+        const captchaResponse = newRequest.phoneSignInInfo.captchaResponse;
+        const clientType = newRequest
+            .phoneSignInInfo.clientType;
+        const recaptchaVersion = newRequest.phoneSignInInfo.recaptchaVersion;
+        Object.assign(newRequest, {
+            'phoneSignInInfo': {
+                recaptchaToken: recaptchaV2Token,
+                captchaResponse,
+                clientType,
+                recaptchaVersion
+            }
+        });
+        return newRequest;
+    }
+    else {
+        Object.assign(newRequest, { 'recaptchaToken': recaptchaV2Token });
+        return newRequest;
+    }
 }
 
 /**
@@ -1096,12 +1062,14 @@ class PhoneAuthProvider {
      *
      * @param phoneInfoOptions - The user's {@link PhoneInfoOptions}. The phone number should be in
      * E.164 format (e.g. +16505550101).
-     * @param applicationVerifier - For abuse prevention, this method also requires a
-     * {@link ApplicationVerifier}. This SDK includes a reCAPTCHA-based implementation,
-     * {@link RecaptchaVerifier}.
+     * @param applicationVerifier - An {@link ApplicationVerifier}, which prevents
+     * requests from unauthorized clients. This SDK includes an implementation
+     * based on reCAPTCHA v2, {@link RecaptchaVerifier}. If you've enabled
+     * reCAPTCHA Enterprise bot protection in Enforce mode, this parameter is
+     * optional; in all other configurations, the parameter is required.
      *
      * @returns A Promise for a verification ID that can be passed to
-     * {@link PhoneAuthProvider.credential} to identify this flow..
+     * {@link PhoneAuthProvider.credential} to identify this flow.
      */
     verifyPhoneNumber(phoneOptions, applicationVerifier) {
         return _verifyPhoneNumber(this.auth, phoneOptions, util.getModularInstance(applicationVerifier));