@firebase/auth 0.19.12 → 0.20.0

package/dist/rn/{phone-eec7f987.js → phone-ae029e3c.js}

@@ -103,6 +103,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.',
@@ -2367,6 +2368,104 @@ function _getClientVersion(clientPlatform, frameworks) {
     return reportedPlatform + "/" + "JsCore" /* CORE */ + "/" + app.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 tslib.__awaiter(this, void 0, void 0, function () {
+            var onAbortStack, _i, _a, beforeStateCallback, e_1, _b, onAbortStack_1, onAbort;
+            return tslib.__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
@@ -2393,6 +2492,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
@@ -2494,9 +2594,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*/];
                 }
@@ -2506,18 +2608,20 @@ var AuthImpl = /** @class */ (function () {
     AuthImpl.prototype.initializeCurrentUser = function (popupRedirectResolver) {
         var _a;
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var storedUser, redirectUserEventId, storedUserEventId, result;
+            var previouslyStoredUser, futureCurrentUser, needsTocheckMiddleware, redirectUserEventId, storedUserEventId, result, e_2;
             return tslib.__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();
@@ -2527,32 +2631,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)];
                 }
             });
         });
@@ -2590,7 +2713,7 @@ var AuthImpl = /** @class */ (function () {
     };
     AuthImpl.prototype.reloadAndSetCurrentUserOrClear = function (user) {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var e_3;
+            var e_4;
             return tslib.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -2600,8 +2723,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)];
@@ -2637,27 +2760,36 @@ var AuthImpl = /** @class */ (function () {
             });
         });
     };
-    AuthImpl.prototype._updateCurrentUser = function (user) {
+    AuthImpl.prototype._updateCurrentUser = function (user, skipBeforeStateCallbacks) {
+        if (skipBeforeStateCallbacks === void 0) { skipBeforeStateCallbacks = false; }
         return tslib.__awaiter(this, void 0, void 0, function () {
             var _this = this;
             return tslib.__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 tslib.__awaiter(_this, void 0, void 0, function () {
+                            return tslib.__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 tslib.__awaiter(_this, void 0, void 0, function () {
-                        return tslib.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.directlySetCurrentUser(user)];
-                                case 1:
-                                    _a.sent();
-                                    this.notifyAuthListeners();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })];
             });
         });
     };
@@ -2665,13 +2797,21 @@ var AuthImpl = /** @class */ (function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
             return tslib.__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)];
                 }
             });
         });
@@ -2698,6 +2838,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);
     };
@@ -6433,6 +6576,19 @@ function setPersistence(auth, persistence) {
 function onIdTokenChanged(auth, nextOrObserver, error, completed) {
     return util.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 util.getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);
+}
 /**
  * Adds an observer for changes to the user's sign-in state.
  *
@@ -6799,7 +6955,7 @@ function multiFactor(user) {
 }
 
 var name = "@firebase/auth";
-var version = "0.19.12";
+var version = "0.20.0";
 
 /**
  * @license
@@ -8276,6 +8432,7 @@ exports._setWindowLocation = _setWindowLocation;
 exports._signInWithCredential = _signInWithCredential;
 exports._window = _window;
 exports.applyActionCode = applyActionCode;
+exports.beforeAuthStateChanged = beforeAuthStateChanged;
 exports.checkActionCode = checkActionCode;
 exports.confirmPasswordReset = confirmPasswordReset;
 exports.connectAuthEmulator = connectAuthEmulator;
@@ -8323,4 +8480,4 @@ exports.updateProfile = updateProfile;
 exports.useDeviceLanguage = useDeviceLanguage;
 exports.verifyBeforeUpdateEmail = verifyBeforeUpdateEmail;
 exports.verifyPasswordResetCode = verifyPasswordResetCode;
-//# sourceMappingURL=phone-eec7f987.js.map
+//# sourceMappingURL=phone-ae029e3c.js.map