@firebase/auth 0.19.12 → 0.20.0

package/dist/cordova/{popup_redirect-fd81f644.js → popup_redirect-1228b67a.js}

@@ -1015,6 +1015,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.',
@@ -3279,6 +3280,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
@@ -3305,6 +3404,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
@@ -3406,9 +3506,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*/];
                 }
@@ -3418,18 +3520,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();
@@ -3439,32 +3543,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)];
                 }
             });
         });
@@ -3502,7 +3625,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:
@@ -3512,8 +3635,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)];
@@ -3549,27 +3672,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*/];
-                            }
-                        });
-                    }); })];
             });
         });
     };
@@ -3577,13 +3709,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)];
                 }
             });
         });
@@ -3610,6 +3750,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);
     };
@@ -7345,6 +7488,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.
  *
@@ -7711,7 +7867,7 @@ function multiFactor(user) {
 }
 
 var name = "@firebase/auth";
-var version = "0.19.12";
+var version = "0.20.0";
 
 /**
  * @license
@@ -8702,6 +8858,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);
 }
@@ -9694,6 +9853,7 @@ var CordovaPopupRedirectResolver = /** @class */ (function () {
         this.eventManagers = new Map();
         this.originValidationPromises = {};
         this._completeRedirectFn = _getRedirectResult;
+        this._overrideRedirectResult = _overrideRedirectResult;
     }
     CordovaPopupRedirectResolver.prototype._initialize = function (auth) {
         return __awaiter(this, void 0, void 0, function () {
@@ -9853,5 +10013,5 @@ function generateNoEvent() {
     };
 }
 
-export { fetchSignInMethodsForEmail as $, ActionCodeOperation as A, GithubAuthProvider as B, OAuthProvider as C, SAMLAuthProvider as D, EmailAuthCredential as E, FactorId as F, GoogleAuthProvider as G, signInAnonymously as H, signInWithCredential as I, linkWithCredential as J, reauthenticateWithCredential as K, signInWithCustomToken as L, sendPasswordResetEmail as M, confirmPasswordReset as N, OperationType as O, ProviderId as P, applyActionCode as Q, checkActionCode as R, SignInMethod as S, TwitterAuthProvider as T, verifyPasswordResetCode as U, createUserWithEmailAndPassword as V, signInWithEmailAndPassword as W, sendSignInLinkToEmail as X, isSignInWithEmailLink as Y, signInWithEmailLink as Z, _signInWithRedirect as _, _reauthenticateWithRedirect as a, sendEmailVerification as a0, verifyBeforeUpdateEmail as a1, ActionCodeURL as a2, parseActionCodeURL as a3, updateProfile as a4, updateEmail as a5, updatePassword as a6, getIdToken as a7, getIdTokenResult as a8, unlink as a9, _emulatorUrl as aA, _isChromeIOS as aB, _isFirefox as aC, _isIOSStandalone as aD, _isMobileBrowser as aE, _isSafari as aF, _isIOS as aG, _getRedirectResult as aH, _getRedirectUrl as aI, _setWindowLocation as aJ, AuthEventManager as aK, debugFail as aL, finalizeEnrollPhoneMfa as aM, _persistenceKeyName as aN, UserImpl as aO, _getInstance as aP, AuthImpl as aQ, _getClientVersion as aR, FetchProvider as aS, SAMLAuthCredential as aT, signInWithRedirect as aU, linkWithRedirect as aV, reauthenticateWithRedirect as aW, getAdditionalUserInfo as aa, reload as ab, getMultiFactorResolver as ac, multiFactor as ad, _performApiRequest as ae, _addTidIfNecessary as af, _createError as ag, _assert as ah, Delay as ai, _window as aj, _isHttpOrHttps as ak, _isWorker as al, _castAuth as am, sendPhoneVerificationCode as an, startEnrollPhoneMfa as ao, _assertLinkedStatus as ap, _link$1 as aq, debugAssert as ar, _generateEventId as as, AbstractPopupRedirectOperation as at, _assertInstanceOf as au, _withDefaultResolver as av, FederatedAuthProvider as aw, _fail as ax, _getProjectConfig as ay, _getCurrentUrl as az, _linkWithRedirect as b, indexedDBLocalPersistence as c, cordovaPopupRedirectResolver as d, browserLocalPersistence as e, browserSessionPersistence as f, getRedirectResult as g, onAuthStateChanged as h, initializeAuth as i, updateCurrentUser as j, signOut as k, deleteUser as l, debugErrorMap as m, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as n, onIdTokenChanged as o, prodErrorMap as p, connectAuthEmulator as q, registerAuth as r, setPersistence as s, AuthCredential as t, useDeviceLanguage as u, OAuthCredential as v, PhoneAuthCredential as w, inMemoryPersistence as x, EmailAuthProvider as y, FacebookAuthProvider as z };
-//# sourceMappingURL=popup_redirect-fd81f644.js.map
+export { signInWithEmailLink as $, ActionCodeOperation as A, FacebookAuthProvider as B, GithubAuthProvider as C, OAuthProvider as D, EmailAuthCredential as E, FactorId as F, GoogleAuthProvider as G, SAMLAuthProvider as H, signInAnonymously as I, signInWithCredential as J, linkWithCredential as K, reauthenticateWithCredential as L, signInWithCustomToken as M, sendPasswordResetEmail as N, OperationType as O, ProviderId as P, confirmPasswordReset as Q, applyActionCode as R, SignInMethod as S, TwitterAuthProvider as T, checkActionCode as U, verifyPasswordResetCode as V, createUserWithEmailAndPassword as W, signInWithEmailAndPassword as X, sendSignInLinkToEmail as Y, isSignInWithEmailLink as Z, _signInWithRedirect as _, _reauthenticateWithRedirect as a, fetchSignInMethodsForEmail as a0, sendEmailVerification as a1, verifyBeforeUpdateEmail as a2, ActionCodeURL as a3, parseActionCodeURL as a4, updateProfile as a5, updateEmail as a6, updatePassword as a7, getIdToken as a8, getIdTokenResult as a9, _getCurrentUrl as aA, _emulatorUrl as aB, _isChromeIOS as aC, _isFirefox as aD, _isIOSStandalone as aE, _isMobileBrowser as aF, _isSafari as aG, _isIOS as aH, _getRedirectResult as aI, _overrideRedirectResult as aJ, _getRedirectUrl as aK, _setWindowLocation as aL, AuthEventManager as aM, debugFail as aN, finalizeEnrollPhoneMfa as aO, _persistenceKeyName as aP, UserImpl as aQ, _getInstance as aR, AuthImpl as aS, _getClientVersion as aT, FetchProvider as aU, SAMLAuthCredential as aV, signInWithRedirect as aW, linkWithRedirect as aX, reauthenticateWithRedirect as aY, unlink as aa, getAdditionalUserInfo as ab, reload as ac, getMultiFactorResolver as ad, multiFactor as ae, _performApiRequest as af, _addTidIfNecessary as ag, _createError as ah, _assert as ai, Delay as aj, _window as ak, _isHttpOrHttps as al, _isWorker as am, _castAuth as an, sendPhoneVerificationCode as ao, startEnrollPhoneMfa as ap, _assertLinkedStatus as aq, _link$1 as ar, debugAssert as as, _generateEventId as at, AbstractPopupRedirectOperation as au, _assertInstanceOf as av, _withDefaultResolver as aw, FederatedAuthProvider as ax, _fail as ay, _getProjectConfig as az, _linkWithRedirect as b, indexedDBLocalPersistence as c, cordovaPopupRedirectResolver as d, browserLocalPersistence as e, browserSessionPersistence as f, getRedirectResult as g, beforeAuthStateChanged as h, initializeAuth as i, onAuthStateChanged as j, updateCurrentUser as k, signOut as l, deleteUser as m, debugErrorMap as n, onIdTokenChanged as o, prodErrorMap as p, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as q, registerAuth as r, setPersistence as s, connectAuthEmulator as t, useDeviceLanguage as u, AuthCredential as v, OAuthCredential as w, PhoneAuthCredential as x, inMemoryPersistence as y, EmailAuthProvider as z };
+//# sourceMappingURL=popup_redirect-1228b67a.js.map