@firebase/auth 0.19.12 → 0.20.0

package/dist/esm5/{index-7a476dcd.js → index-dc27d95e.js}

@@ -199,6 +199,7 @@ function _debugErrorMap() {
             'Please fix by going to the Auth email templates section in the Firebase Console.',
         _a["invalid-verification-id" /* INVALID_SESSION_INFO */] = 'The verification ID used to create the phone auth credential is invalid.',
         _a["invalid-tenant-id" /* INVALID_TENANT_ID */] = "The Auth instance's tenant ID is invalid.",
+        _a["login-blocked" /* LOGIN_BLOCKED */] = "Login blocked by user-provided method: {$originalMessage}",
         _a["missing-android-pkg-name" /* MISSING_ANDROID_PACKAGE_NAME */] = 'An Android Package Name must be provided if the Android App is required to be installed.',
         _a["auth-domain-config-required" /* MISSING_AUTH_DOMAIN */] = 'Be sure to include authDomain when calling firebase.initializeApp(), ' +
             'by following the instructions in the Firebase console.',
@@ -2463,6 +2464,104 @@ function _getClientVersion(clientPlatform, frameworks) {
     return reportedPlatform + "/" + "JsCore" /* CORE */ + "/" + SDK_VERSION + "/" + reportedFrameworks;
 }
 
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+var AuthMiddlewareQueue = /** @class */ (function () {
+    function AuthMiddlewareQueue(auth) {
+        this.auth = auth;
+        this.queue = [];
+    }
+    AuthMiddlewareQueue.prototype.pushCallback = function (callback, onAbort) {
+        var _this = this;
+        // The callback could be sync or async. Wrap it into a
+        // function that is always async.
+        var wrappedCallback = function (user) { return new Promise(function (resolve, reject) {
+            try {
+                var result = callback(user);
+                // Either resolve with existing promise or wrap a non-promise
+                // return value into a promise.
+                resolve(result);
+            }
+            catch (e) {
+                // Sync callback throws.
+                reject(e);
+            }
+        }); };
+        // Attach the onAbort if present
+        wrappedCallback.onAbort = onAbort;
+        this.queue.push(wrappedCallback);
+        var index = this.queue.length - 1;
+        return function () {
+            // Unsubscribe. Replace with no-op. Do not remove from array, or it will disturb
+            // indexing of other elements.
+            _this.queue[index] = function () { return Promise.resolve(); };
+        };
+    };
+    AuthMiddlewareQueue.prototype.runMiddleware = function (nextUser) {
+        return __awaiter(this, void 0, void 0, function () {
+            var onAbortStack, _i, _a, beforeStateCallback, e_1, _b, onAbortStack_1, onAbort;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.auth.currentUser === nextUser) {
+                            return [2 /*return*/];
+                        }
+                        onAbortStack = [];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, , 7]);
+                        _i = 0, _a = this.queue;
+                        _c.label = 2;
+                    case 2:
+                        if (!(_i < _a.length)) return [3 /*break*/, 5];
+                        beforeStateCallback = _a[_i];
+                        return [4 /*yield*/, beforeStateCallback(nextUser)];
+                    case 3:
+                        _c.sent();
+                        // Only push the onAbort if the callback succeeds
+                        if (beforeStateCallback.onAbort) {
+                            onAbortStack.push(beforeStateCallback.onAbort);
+                        }
+                        _c.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        e_1 = _c.sent();
+                        // Run all onAbort, with separate try/catch to ignore any errors and
+                        // continue
+                        onAbortStack.reverse();
+                        for (_b = 0, onAbortStack_1 = onAbortStack; _b < onAbortStack_1.length; _b++) {
+                            onAbort = onAbortStack_1[_b];
+                            try {
+                                onAbort();
+                            }
+                            catch (_) { /* swallow error */ }
+                        }
+                        throw this.auth._errorFactory.create("login-blocked" /* LOGIN_BLOCKED */, { originalMessage: e_1.message });
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AuthMiddlewareQueue;
+}());
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -2489,6 +2588,7 @@ var AuthImpl = /** @class */ (function () {
         this.operations = Promise.resolve();
         this.authStateSubscription = new Subscription(this);
         this.idTokenSubscription = new Subscription(this);
+        this.beforeStateQueue = new AuthMiddlewareQueue(this);
         this.redirectUser = null;
         this.isProactiveRefreshEnabled = false;
         // Any network calls will set this to true and prevent subsequent emulator
@@ -2590,9 +2690,11 @@ var AuthImpl = /** @class */ (function () {
                         return [2 /*return*/];
                     case 3: 
                     // Update current Auth state. Either a new login or logout.
-                    return [4 /*yield*/, this._updateCurrentUser(user)];
+                    // Skip blocking callbacks, they should not apply to a change in another tab.
+                    return [4 /*yield*/, this._updateCurrentUser(user, /* skipBeforeStateCallbacks */ true)];
                     case 4:
                         // Update current Auth state. Either a new login or logout.
+                        // Skip blocking callbacks, they should not apply to a change in another tab.
                         _a.sent();
                         return [2 /*return*/];
                 }
@@ -2602,18 +2704,20 @@ var AuthImpl = /** @class */ (function () {
     AuthImpl.prototype.initializeCurrentUser = function (popupRedirectResolver) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var storedUser, redirectUserEventId, storedUserEventId, result;
+            var previouslyStoredUser, futureCurrentUser, needsTocheckMiddleware, redirectUserEventId, storedUserEventId, result, e_2;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.assertedPersistence.getCurrentUser()];
                     case 1:
-                        storedUser = (_b.sent());
+                        previouslyStoredUser = (_b.sent());
+                        futureCurrentUser = previouslyStoredUser;
+                        needsTocheckMiddleware = false;
                         if (!(popupRedirectResolver && this.config.authDomain)) return [3 /*break*/, 4];
                         return [4 /*yield*/, this.getOrInitRedirectPersistenceManager()];
                     case 2:
                         _b.sent();
                         redirectUserEventId = (_a = this.redirectUser) === null || _a === void 0 ? void 0 : _a._redirectEventId;
-                        storedUserEventId = storedUser === null || storedUser === void 0 ? void 0 : storedUser._redirectEventId;
+                        storedUserEventId = futureCurrentUser === null || futureCurrentUser === void 0 ? void 0 : futureCurrentUser._redirectEventId;
                         return [4 /*yield*/, this.tryRedirectSignIn(popupRedirectResolver)];
                     case 3:
                         result = _b.sent();
@@ -2623,32 +2727,51 @@ var AuthImpl = /** @class */ (function () {
                         // TODO(samgho): More thoroughly test all of this
                         if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) &&
                             (result === null || result === void 0 ? void 0 : result.user)) {
-                            storedUser = result.user;
+                            futureCurrentUser = result.user;
+                            needsTocheckMiddleware = true;
                         }
                         _b.label = 4;
                     case 4:
                         // If no user in persistence, there is no current user. Set to null.
-                        if (!storedUser) {
+                        if (!futureCurrentUser) {
                             return [2 /*return*/, this.directlySetCurrentUser(null)];
                         }
-                        if (!storedUser._redirectEventId) {
-                            // This isn't a redirect user, we can reload and bail
-                            // This will also catch the redirected user, if available, as that method
-                            // strips the _redirectEventId
-                            return [2 /*return*/, this.reloadAndSetCurrentUserOrClear(storedUser)];
+                        if (!!futureCurrentUser._redirectEventId) return [3 /*break*/, 9];
+                        if (!needsTocheckMiddleware) return [3 /*break*/, 8];
+                        _b.label = 5;
+                    case 5:
+                        _b.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, this.beforeStateQueue.runMiddleware(futureCurrentUser)];
+                    case 6:
+                        _b.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        e_2 = _b.sent();
+                        futureCurrentUser = previouslyStoredUser;
+                        // We know this is available since the bit is only set when the
+                        // resolver is available
+                        this._popupRedirectResolver._overrideRedirectResult(this, function () { return Promise.reject(e_2); });
+                        return [3 /*break*/, 8];
+                    case 8:
+                        if (futureCurrentUser) {
+                            return [2 /*return*/, this.reloadAndSetCurrentUserOrClear(futureCurrentUser)];
                         }
+                        else {
+                            return [2 /*return*/, this.directlySetCurrentUser(null)];
+                        }
+                    case 9:
                         _assert(this._popupRedirectResolver, this, "argument-error" /* ARGUMENT_ERROR */);
                         return [4 /*yield*/, this.getOrInitRedirectPersistenceManager()];
-                    case 5:
+                    case 10:
                         _b.sent();
                         // If the redirect user's event ID matches the current user's event ID,
                         // DO NOT reload the current user, otherwise they'll be cleared from storage.
                         // This is important for the reauthenticateWithRedirect() flow.
                         if (this.redirectUser &&
-                            this.redirectUser._redirectEventId === storedUser._redirectEventId) {
-                            return [2 /*return*/, this.directlySetCurrentUser(storedUser)];
+                            this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
+                            return [2 /*return*/, this.directlySetCurrentUser(futureCurrentUser)];
                         }
-                        return [2 /*return*/, this.reloadAndSetCurrentUserOrClear(storedUser)];
+                        return [2 /*return*/, this.reloadAndSetCurrentUserOrClear(futureCurrentUser)];
                 }
             });
         });
@@ -2686,7 +2809,7 @@ var AuthImpl = /** @class */ (function () {
     };
     AuthImpl.prototype.reloadAndSetCurrentUserOrClear = function (user) {
         return __awaiter(this, void 0, void 0, function () {
-            var e_3;
+            var e_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -2696,8 +2819,8 @@ var AuthImpl = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 3];
                     case 2:
-                        e_3 = _a.sent();
-                        if (e_3.code !== "auth/" + "network-request-failed" /* NETWORK_REQUEST_FAILED */) {
+                        e_4 = _a.sent();
+                        if (e_4.code !== "auth/" + "network-request-failed" /* NETWORK_REQUEST_FAILED */) {
                             // Something's wrong with the user's token. Log them out and remove
                             // them from storage
                             return [2 /*return*/, this.directlySetCurrentUser(null)];
@@ -2733,27 +2856,36 @@ var AuthImpl = /** @class */ (function () {
             });
         });
     };
-    AuthImpl.prototype._updateCurrentUser = function (user) {
+    AuthImpl.prototype._updateCurrentUser = function (user, skipBeforeStateCallbacks) {
+        if (skipBeforeStateCallbacks === void 0) { skipBeforeStateCallbacks = false; }
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                if (this._deleted) {
-                    return [2 /*return*/];
-                }
-                if (user) {
-                    _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" /* TENANT_ID_MISMATCH */);
+                switch (_a.label) {
+                    case 0:
+                        if (this._deleted) {
+                            return [2 /*return*/];
+                        }
+                        if (user) {
+                            _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" /* TENANT_ID_MISMATCH */);
+                        }
+                        if (!!skipBeforeStateCallbacks) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.beforeStateQueue.runMiddleware(user)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.queue(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.directlySetCurrentUser(user)];
+                                    case 1:
+                                        _a.sent();
+                                        this.notifyAuthListeners();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                 }
-                return [2 /*return*/, this.queue(function () { return __awaiter(_this, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.directlySetCurrentUser(user)];
-                                case 1:
-                                    _a.sent();
-                                    this.notifyAuthListeners();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })];
             });
         });
     };
@@ -2761,13 +2893,21 @@ var AuthImpl = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        if (!(this.redirectPersistenceManager || this._popupRedirectResolver)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._setRedirectUser(null)];
+                    case 0: 
+                    // Run first, to block _setRedirectUser() if any callbacks fail.
+                    return [4 /*yield*/, this.beforeStateQueue.runMiddleware(null)];
                     case 1:
+                        // Run first, to block _setRedirectUser() if any callbacks fail.
                         _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, this._updateCurrentUser(null)];
+                        if (!(this.redirectPersistenceManager || this._popupRedirectResolver)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._setRedirectUser(null)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: 
+                    // Prevent callbacks from being called again in _updateCurrentUser, as
+                    // they were already called in the first line.
+                    return [2 /*return*/, this._updateCurrentUser(null, /* skipBeforeStateCallbacks */ true)];
                 }
             });
         });
@@ -2794,6 +2934,9 @@ var AuthImpl = /** @class */ (function () {
     AuthImpl.prototype.onAuthStateChanged = function (nextOrObserver, error, completed) {
         return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
     };
+    AuthImpl.prototype.beforeAuthStateChanged = function (callback, onAbort) {
+        return this.beforeStateQueue.pushCallback(callback, onAbort);
+    };
     AuthImpl.prototype.onIdTokenChanged = function (nextOrObserver, error, completed) {
         return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
     };
@@ -6529,6 +6672,19 @@ function setPersistence(auth, persistence) {
 function onIdTokenChanged(auth, nextOrObserver, error, completed) {
     return getModularInstance(auth).onIdTokenChanged(nextOrObserver, error, completed);
 }
+/**
+ * Adds a blocking callback that runs before an auth state change
+ * sets a new user.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param callback - callback triggered before new user value is set.
+ *   If this throws, it blocks the user from being set.
+ * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+ *   callback throws, allowing you to undo any side effects.
+ */
+function beforeAuthStateChanged(auth, callback, onAbort) {
+    return getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);
+}
 /**
  * Adds an observer for changes to the user's sign-in state.
  *
@@ -9779,6 +9935,9 @@ function _setPendingRedirectStatus(resolver, auth) {
 function _clearRedirectOutcomes() {
     redirectOutcomeMap.clear();
 }
+function _overrideRedirectResult(auth, result) {
+    redirectOutcomeMap.set(auth._key(), result);
+}
 function resolverPersistence(resolver) {
     return _getInstance(resolver._redirectPersistence);
 }
@@ -10700,6 +10859,7 @@ var BrowserPopupRedirectResolver = /** @class */ (function () {
         this.originValidationPromises = {};
         this._redirectPersistence = browserSessionPersistence;
         this._completeRedirectFn = _getRedirectResult;
+        this._overrideRedirectResult = _overrideRedirectResult;
     }
     // Wrapping in async even though we don't await anywhere in order
     // to make sure errors are raised as promise rejections
@@ -10883,7 +11043,7 @@ var PhoneMultiFactorGenerator = /** @class */ (function () {
 }());
 
 var name = "@firebase/auth";
-var version = "0.19.12";
+var version = "0.20.0";
 
 /**
  * @license
@@ -11088,5 +11248,5 @@ function getAuth(app) {
 }
 registerAuth("Browser" /* BROWSER */);
 
-export { sendPasswordResetEmail as $, ActionCodeOperation as A, prodErrorMap as B, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as C, initializeAuth as D, connectAuthEmulator as E, FactorId as F, AuthCredential as G, EmailAuthCredential as H, OAuthCredential as I, PhoneAuthCredential as J, inMemoryPersistence as K, EmailAuthProvider as L, FacebookAuthProvider as M, GoogleAuthProvider as N, OperationType as O, PhoneAuthProvider as P, GithubAuthProvider as Q, RecaptchaVerifier as R, SignInMethod as S, OAuthProvider as T, SAMLAuthProvider as U, TwitterAuthProvider as V, signInAnonymously as W, signInWithCredential as X, linkWithCredential as Y, reauthenticateWithCredential as Z, signInWithCustomToken as _, browserSessionPersistence as a, confirmPasswordReset as a0, applyActionCode as a1, checkActionCode as a2, verifyPasswordResetCode as a3, createUserWithEmailAndPassword as a4, signInWithEmailAndPassword as a5, sendSignInLinkToEmail as a6, isSignInWithEmailLink as a7, signInWithEmailLink as a8, fetchSignInMethodsForEmail as a9, _clearRedirectOutcomes as aA, _getRedirectResult as aB, _castAuth as aC, UserImpl as aD, AuthImpl as aE, _getClientVersion as aF, _generateEventId as aG, AuthPopup as aH, FetchProvider as aI, SAMLAuthCredential as aJ, sendEmailVerification as aa, verifyBeforeUpdateEmail as ab, ActionCodeURL as ac, parseActionCodeURL as ad, updateProfile as ae, updateEmail as af, updatePassword as ag, getIdToken as ah, getIdTokenResult as ai, unlink as aj, getAdditionalUserInfo as ak, reload as al, getMultiFactorResolver as am, multiFactor as an, _isAndroid as ao, _isIOS7Or8 as ap, _isIOS as aq, _fail as ar, _getRedirectUrl as as, debugAssert as at, _getProjectConfig as au, _createError as av, _assert as aw, AuthEventManager as ax, _getInstance as ay, _persistenceKeyName as az, browserLocalPersistence as b, signInWithPopup as c, linkWithPopup as d, reauthenticateWithPopup as e, signInWithRedirect as f, linkWithRedirect as g, reauthenticateWithRedirect as h, indexedDBLocalPersistence as i, getRedirectResult as j, browserPopupRedirectResolver as k, linkWithPhoneNumber as l, PhoneMultiFactorGenerator as m, getAuth as n, ProviderId as o, setPersistence as p, onIdTokenChanged as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, onAuthStateChanged as t, updatePhoneNumber as u, useDeviceLanguage as v, updateCurrentUser as w, signOut as x, deleteUser as y, debugErrorMap as z };
-//# sourceMappingURL=index-7a476dcd.js.map
+export { signInWithCustomToken as $, ActionCodeOperation as A, debugErrorMap as B, prodErrorMap as C, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as D, initializeAuth as E, FactorId as F, connectAuthEmulator as G, AuthCredential as H, EmailAuthCredential as I, OAuthCredential as J, PhoneAuthCredential as K, inMemoryPersistence as L, EmailAuthProvider as M, FacebookAuthProvider as N, OperationType as O, PhoneAuthProvider as P, GoogleAuthProvider as Q, RecaptchaVerifier as R, SignInMethod as S, GithubAuthProvider as T, OAuthProvider as U, SAMLAuthProvider as V, TwitterAuthProvider as W, signInAnonymously as X, signInWithCredential as Y, linkWithCredential as Z, reauthenticateWithCredential as _, browserSessionPersistence as a, sendPasswordResetEmail as a0, confirmPasswordReset as a1, applyActionCode as a2, checkActionCode as a3, verifyPasswordResetCode as a4, createUserWithEmailAndPassword as a5, signInWithEmailAndPassword as a6, sendSignInLinkToEmail as a7, isSignInWithEmailLink as a8, signInWithEmailLink as a9, _persistenceKeyName as aA, _clearRedirectOutcomes as aB, _getRedirectResult as aC, _overrideRedirectResult as aD, _castAuth as aE, UserImpl as aF, AuthImpl as aG, _getClientVersion as aH, _generateEventId as aI, AuthPopup as aJ, FetchProvider as aK, SAMLAuthCredential as aL, fetchSignInMethodsForEmail as aa, sendEmailVerification as ab, verifyBeforeUpdateEmail as ac, ActionCodeURL as ad, parseActionCodeURL as ae, updateProfile as af, updateEmail as ag, updatePassword as ah, getIdToken as ai, getIdTokenResult as aj, unlink as ak, getAdditionalUserInfo as al, reload as am, getMultiFactorResolver as an, multiFactor as ao, _isAndroid as ap, _isIOS7Or8 as aq, _isIOS as ar, _fail as as, _getRedirectUrl as at, debugAssert as au, _getProjectConfig as av, _createError as aw, _assert as ax, AuthEventManager as ay, _getInstance as az, browserLocalPersistence as b, signInWithPopup as c, linkWithPopup as d, reauthenticateWithPopup as e, signInWithRedirect as f, linkWithRedirect as g, reauthenticateWithRedirect as h, indexedDBLocalPersistence as i, getRedirectResult as j, browserPopupRedirectResolver as k, linkWithPhoneNumber as l, PhoneMultiFactorGenerator as m, getAuth as n, ProviderId as o, setPersistence as p, onIdTokenChanged as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, beforeAuthStateChanged as t, updatePhoneNumber as u, onAuthStateChanged as v, useDeviceLanguage as w, updateCurrentUser as x, signOut as y, deleteUser as z };
+//# sourceMappingURL=index-dc27d95e.js.map