@firebase/auth 0.19.12 → 0.20.0

package/dist/index.webworker.esm5.js

@@ -101,6 +101,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.',
@@ -522,7 +523,7 @@ function _initializeAuthInstance(auth, deps) {
 }
 
 var name = "@firebase/auth";
-var version = "0.19.12";
+var version = "0.20.0";
 
 /**
  * @license
@@ -2321,6 +2322,104 @@ var PersistenceUserManager = /** @class */ (function () {
     return PersistenceUserManager;
 }());
 
+/**
+ * @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
@@ -2347,6 +2446,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
@@ -2448,9 +2548,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*/];
                 }
@@ -2460,18 +2562,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();
@@ -2481,32 +2585,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)];
                 }
             });
         });
@@ -2544,7 +2667,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:
@@ -2554,8 +2677,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)];
@@ -2591,27 +2714,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*/];
-                            }
-                        });
-                    }); })];
             });
         });
     };
@@ -2619,13 +2751,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)];
                 }
             });
         });
@@ -2652,6 +2792,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);
     };
@@ -7551,6 +7694,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.
  *
@@ -7944,5 +8100,5 @@ function getAuth(app) {
     return auth;
 }
 
-export { ActionCodeOperation, ActionCodeURL, AuthCredential, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes, EmailAuthCredential, EmailAuthProvider, FacebookAuthProvider, FactorId, GithubAuthProvider, GoogleAuthProvider, OAuthCredential, OAuthProvider, OperationType, PhoneAuthCredential, ProviderId, SAMLAuthProvider, SignInMethod, TwitterAuthProvider, applyActionCode, checkActionCode, confirmPasswordReset, connectAuthEmulator, createUserWithEmailAndPassword, debugErrorMap, deleteUser, fetchSignInMethodsForEmail, getAdditionalUserInfo, getAuth, getIdToken, getIdTokenResult, getMultiFactorResolver, inMemoryPersistence, indexedDBLocalPersistence, initializeAuth, isSignInWithEmailLink, linkWithCredential, multiFactor, onAuthStateChanged, onIdTokenChanged, parseActionCodeURL, prodErrorMap, reauthenticateWithCredential, reload, sendEmailVerification, sendPasswordResetEmail, sendSignInLinkToEmail, setPersistence, signInAnonymously, signInWithCredential, signInWithCustomToken, signInWithEmailAndPassword, signInWithEmailLink, signOut, unlink, updateCurrentUser, updateEmail, updatePassword, updateProfile, useDeviceLanguage, verifyBeforeUpdateEmail, verifyPasswordResetCode };
+export { ActionCodeOperation, ActionCodeURL, AuthCredential, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes, EmailAuthCredential, EmailAuthProvider, FacebookAuthProvider, FactorId, GithubAuthProvider, GoogleAuthProvider, OAuthCredential, OAuthProvider, OperationType, PhoneAuthCredential, ProviderId, SAMLAuthProvider, SignInMethod, TwitterAuthProvider, applyActionCode, beforeAuthStateChanged, checkActionCode, confirmPasswordReset, connectAuthEmulator, createUserWithEmailAndPassword, debugErrorMap, deleteUser, fetchSignInMethodsForEmail, getAdditionalUserInfo, getAuth, getIdToken, getIdTokenResult, getMultiFactorResolver, inMemoryPersistence, indexedDBLocalPersistence, initializeAuth, isSignInWithEmailLink, linkWithCredential, multiFactor, onAuthStateChanged, onIdTokenChanged, parseActionCodeURL, prodErrorMap, reauthenticateWithCredential, reload, sendEmailVerification, sendPasswordResetEmail, sendSignInLinkToEmail, setPersistence, signInAnonymously, signInWithCredential, signInWithCustomToken, signInWithEmailAndPassword, signInWithEmailLink, signOut, unlink, updateCurrentUser, updateEmail, updatePassword, updateProfile, useDeviceLanguage, verifyBeforeUpdateEmail, verifyPasswordResetCode };
 //# sourceMappingURL=index.webworker.esm5.js.map