import firebase from '@firebase/app-compat'; import * as exp from '@firebase/auth/internal'; import { Component } from '@firebase/component'; import { isBrowserExtension, getUA, isReactNative, isNode, isIndexedDBAvailable, isIE, FirebaseError } from '@firebase/util'; import { __awaiter, __generator } from 'tslib'; var name = "@firebase/auth-compat"; var version = "0.3.1"; /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var CORDOVA_ONDEVICEREADY_TIMEOUT_MS = 1000; function _getCurrentScheme() { var _a; return ((_a = self === null || self === void 0 ? void 0 : self.location) === null || _a === void 0 ? void 0 : _a.protocol) || null; } /** * @return {boolean} Whether the current environment is http or https. */ function _isHttpOrHttps() { return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:'; } /** * @param {?string=} ua The user agent. * @return {boolean} Whether the app is rendered in a mobile iOS or Android * Cordova environment. */ function _isAndroidOrIosCordovaScheme(ua) { if (ua === void 0) { ua = getUA(); } return !!((_getCurrentScheme() === 'file:' || _getCurrentScheme() === 'ionic:' || _getCurrentScheme() === 'capacitor:') && ua.toLowerCase().match(/iphone|ipad|ipod|android/)); } /** * @return {boolean} Whether the environment is a native environment, where * CORS checks do not apply. */ function _isNativeEnvironment() { return isReactNative() || isNode(); } /** * Checks whether the user agent is IE11. * @return {boolean} True if it is IE11. */ function _isIe11() { return isIE() && (document === null || document === void 0 ? void 0 : document.documentMode) === 11; } /** * Checks whether the user agent is Edge. * @param {string} userAgent The browser user agent string. * @return {boolean} True if it is Edge. */ function _isEdge(ua) { if (ua === void 0) { ua = getUA(); } return /Edge\/\d+/.test(ua); } /** * @param {?string=} opt_userAgent The navigator user agent. * @return {boolean} Whether local storage is not synchronized between an iframe * and a popup of the same domain. */ function _isLocalStorageNotSynchronized(ua) { if (ua === void 0) { ua = getUA(); } return _isIe11() || _isEdge(ua); } /** @return {boolean} Whether web storage is supported. */ function _isWebStorageSupported() { try { var storage = self.localStorage; var key = exp._generateEventId(); if (storage) { // setItem will throw an exception if we cannot access WebStorage (e.g., // Safari in private mode). storage['setItem'](key, '1'); storage['removeItem'](key); // For browsers where iframe web storage does not synchronize with a popup // of the same domain, indexedDB is used for persistent storage. These // browsers include IE11 and Edge. // Make sure it is supported (IE11 and Edge private mode does not support // that). if (_isLocalStorageNotSynchronized()) { // In such browsers, if indexedDB is not supported, an iframe cannot be // notified of the popup sign in result. return isIndexedDBAvailable(); } return true; } } catch (e) { // localStorage is not available from a worker. Test availability of // indexedDB. return _isWorker() && isIndexedDBAvailable(); } return false; } /** * @param {?Object=} global The optional global scope. * @return {boolean} Whether current environment is a worker. */ function _isWorker() { // WorkerGlobalScope only defined in worker environment. return (typeof global !== 'undefined' && 'WorkerGlobalScope' in global && 'importScripts' in global); } function _isPopupRedirectSupported() { return ((_isHttpOrHttps() || isBrowserExtension() || _isAndroidOrIosCordovaScheme()) && // React Native with remote debugging reports its location.protocol as // http. !_isNativeEnvironment() && // Local storage has to be supported for browser popup and redirect // operations to work. _isWebStorageSupported() && // DOM, popups and redirects are not supported within a worker. !_isWorker()); } /** Quick check that indicates the platform *may* be Cordova */ function _isLikelyCordova() { return _isAndroidOrIosCordovaScheme() && typeof document !== 'undefined'; } function _isCordova() { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { if (!_isLikelyCordova()) { return [2 /*return*/, false]; } return [2 /*return*/, new Promise(function (resolve) { var timeoutId = setTimeout(function () { // We've waited long enough; the telltale Cordova event didn't happen resolve(false); }, CORDOVA_ONDEVICEREADY_TIMEOUT_MS); document.addEventListener('deviceready', function () { clearTimeout(timeoutId); resolve(true); }); })]; }); }); } function _getSelfWindow() { return typeof window !== 'undefined' ? window : null; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var Persistence = { LOCAL: 'local', NONE: 'none', SESSION: 'session' }; var _assert$3 = exp._assert; var PERSISTENCE_KEY = 'persistence'; /** * Validates that an argument is a valid persistence value. If an invalid type * is specified, an error is thrown synchronously. */ function _validatePersistenceArgument(auth, persistence) { _assert$3(Object.values(Persistence).includes(persistence), auth, "invalid-persistence-type" /* exp.AuthErrorCode.INVALID_PERSISTENCE */); // Validate if the specified type is supported in the current environment. if (isReactNative()) { // This is only supported in a browser. _assert$3(persistence !== Persistence.SESSION, auth, "unsupported-persistence-type" /* exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE */); return; } if (isNode()) { // Only none is supported in Node.js. _assert$3(persistence === Persistence.NONE, auth, "unsupported-persistence-type" /* exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE */); return; } if (_isWorker()) { // In a worker environment, either LOCAL or NONE are supported. // If indexedDB not supported and LOCAL provided, throw an error _assert$3(persistence === Persistence.NONE || (persistence === Persistence.LOCAL && isIndexedDBAvailable()), auth, "unsupported-persistence-type" /* exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE */); return; } // This is restricted by what the browser supports. _assert$3(persistence === Persistence.NONE || _isWebStorageSupported(), auth, "unsupported-persistence-type" /* exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE */); } function _savePersistenceForRedirect(auth) { return __awaiter(this, void 0, void 0, function () { var session, key; return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, auth._initializationPromise]; case 1: _a.sent(); session = getSessionStorageIfAvailable(); key = exp._persistenceKeyName(PERSISTENCE_KEY, auth.config.apiKey, auth.name); if (session) { session.setItem(key, auth._getPersistence()); } return [2 /*return*/]; } }); }); } function _getPersistencesFromRedirect(apiKey, appName) { var session = getSessionStorageIfAvailable(); if (!session) { return []; } var key = exp._persistenceKeyName(PERSISTENCE_KEY, apiKey, appName); var persistence = session.getItem(key); switch (persistence) { case Persistence.NONE: return [exp.inMemoryPersistence]; case Persistence.LOCAL: return [exp.indexedDBLocalPersistence, exp.browserSessionPersistence]; case Persistence.SESSION: return [exp.browserSessionPersistence]; default: return []; } } /** Returns session storage, or null if the property access errors */ function getSessionStorageIfAvailable() { var _a; try { return ((_a = _getSelfWindow()) === null || _a === void 0 ? void 0 : _a.sessionStorage) || null; } catch (e) { return null; } } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var _assert$2 = exp._assert; /** Platform-agnostic popup-redirect resolver */ var CompatPopupRedirectResolver = /** @class */ (function () { function CompatPopupRedirectResolver() { // Create both resolvers for dynamic resolution later this.browserResolver = exp._getInstance(exp.browserPopupRedirectResolver); this.cordovaResolver = exp._getInstance(exp.cordovaPopupRedirectResolver); // The actual resolver in use: either browserResolver or cordovaResolver. this.underlyingResolver = null; this._redirectPersistence = exp.browserSessionPersistence; this._completeRedirectFn = exp._getRedirectResult; this._overrideRedirectResult = exp._overrideRedirectResult; } CompatPopupRedirectResolver.prototype._initialize = function (auth) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, this.selectUnderlyingResolver()]; case 1: _a.sent(); return [2 /*return*/, this.assertedUnderlyingResolver._initialize(auth)]; } }); }); }; CompatPopupRedirectResolver.prototype._openPopup = function (auth, provider, authType, eventId) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, this.selectUnderlyingResolver()]; case 1: _a.sent(); return [2 /*return*/, this.assertedUnderlyingResolver._openPopup(auth, provider, authType, eventId)]; } }); }); }; CompatPopupRedirectResolver.prototype._openRedirect = function (auth, provider, authType, eventId) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, this.selectUnderlyingResolver()]; case 1: _a.sent(); return [2 /*return*/, this.assertedUnderlyingResolver._openRedirect(auth, provider, authType, eventId)]; } }); }); }; CompatPopupRedirectResolver.prototype._isIframeWebStorageSupported = function (auth, cb) { this.assertedUnderlyingResolver._isIframeWebStorageSupported(auth, cb); }; CompatPopupRedirectResolver.prototype._originValidation = function (auth) { return this.assertedUnderlyingResolver._originValidation(auth); }; Object.defineProperty(CompatPopupRedirectResolver.prototype, "_shouldInitProactively", { get: function () { return _isLikelyCordova() || this.browserResolver._shouldInitProactively; }, enumerable: false, configurable: true }); Object.defineProperty(CompatPopupRedirectResolver.prototype, "assertedUnderlyingResolver", { get: function () { _assert$2(this.underlyingResolver, "internal-error" /* exp.AuthErrorCode.INTERNAL_ERROR */); return this.underlyingResolver; }, enumerable: false, configurable: true }); CompatPopupRedirectResolver.prototype.selectUnderlyingResolver = function () { return __awaiter(this, void 0, void 0, function () { var isCordova; return __generator(this, function (_a) { switch (_a.label) { case 0: if (this.underlyingResolver) { return [2 /*return*/]; } return [4 /*yield*/, _isCordova()]; case 1: isCordova = _a.sent(); this.underlyingResolver = isCordova ? this.cordovaResolver : this.browserResolver; return [2 /*return*/]; } }); }); }; return CompatPopupRedirectResolver; }()); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function unwrap(object) { return object.unwrap(); } function wrapped(object) { return object.wrapped(); } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function credentialFromResponse(userCredential) { return credentialFromObject(userCredential); } function attachExtraErrorFields(auth, e) { var _a; // The response contains all fields from the server which may or may not // actually match the underlying type var response = (_a = e.customData) === null || _a === void 0 ? void 0 : _a._tokenResponse; if ((e === null || e === void 0 ? void 0 : e.code) === 'auth/multi-factor-auth-required') { var mfaErr = e; mfaErr.resolver = new MultiFactorResolver(auth, exp.getMultiFactorResolver(auth, e)); } else if (response) { var credential = credentialFromObject(e); var credErr = e; if (credential) { credErr.credential = credential; credErr.tenantId = response.tenantId || undefined; credErr.email = response.email || undefined; credErr.phoneNumber = response.phoneNumber || undefined; } } } function credentialFromObject(object) { var _tokenResponse = (object instanceof FirebaseError ? object.customData : object)._tokenResponse; if (!_tokenResponse) { return null; } // Handle phone Auth credential responses, as they have a different format // from other backend responses (i.e. no providerId). This is also only the // case for user credentials (does not work for errors). if (!(object instanceof FirebaseError)) { if ('temporaryProof' in _tokenResponse && 'phoneNumber' in _tokenResponse) { return exp.PhoneAuthProvider.credentialFromResult(object); } } var providerId = _tokenResponse.providerId; // Email and password is not supported as there is no situation where the // server would return the password to the client. if (!providerId || providerId === exp.ProviderId.PASSWORD) { return null; } var provider; switch (providerId) { case exp.ProviderId.GOOGLE: provider = exp.GoogleAuthProvider; break; case exp.ProviderId.FACEBOOK: provider = exp.FacebookAuthProvider; break; case exp.ProviderId.GITHUB: provider = exp.GithubAuthProvider; break; case exp.ProviderId.TWITTER: provider = exp.TwitterAuthProvider; break; default: var _a = _tokenResponse, oauthIdToken = _a.oauthIdToken, oauthAccessToken = _a.oauthAccessToken, oauthTokenSecret = _a.oauthTokenSecret, pendingToken = _a.pendingToken, nonce = _a.nonce; if (!oauthAccessToken && !oauthTokenSecret && !oauthIdToken && !pendingToken) { return null; } // TODO(avolkovi): uncomment this and get it working with SAML & OIDC if (pendingToken) { if (providerId.startsWith('saml.')) { return exp.SAMLAuthCredential._create(providerId, pendingToken); } else { // OIDC and non-default providers excluding Twitter. return exp.OAuthCredential._fromParams({ providerId: providerId, signInMethod: providerId, pendingToken: pendingToken, idToken: oauthIdToken, accessToken: oauthAccessToken }); } } return new exp.OAuthProvider(providerId).credential({ idToken: oauthIdToken, accessToken: oauthAccessToken, rawNonce: nonce }); } return object instanceof FirebaseError ? provider.credentialFromError(object) : provider.credentialFromResult(object); } function convertCredential(auth, credentialPromise) { return credentialPromise .catch(function (e) { if (e instanceof FirebaseError) { attachExtraErrorFields(auth, e); } throw e; }) .then(function (credential) { var operationType = credential.operationType; var user = credential.user; return { operationType: operationType, credential: credentialFromResponse(credential), additionalUserInfo: exp.getAdditionalUserInfo(credential), user: User.getOrCreate(user) }; }); } function convertConfirmationResult(auth, confirmationResultPromise) { return __awaiter(this, void 0, void 0, function () { var confirmationResultExp; return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, confirmationResultPromise]; case 1: confirmationResultExp = _a.sent(); return [2 /*return*/, { verificationId: confirmationResultExp.verificationId, confirm: function (verificationCode) { return convertCredential(auth, confirmationResultExp.confirm(verificationCode)); } }]; } }); }); } var MultiFactorResolver = /** @class */ (function () { function MultiFactorResolver(auth, resolver) { this.resolver = resolver; this.auth = wrapped(auth); } Object.defineProperty(MultiFactorResolver.prototype, "session", { get: function () { return this.resolver.session; }, enumerable: false, configurable: true }); Object.defineProperty(MultiFactorResolver.prototype, "hints", { get: function () { return this.resolver.hints; }, enumerable: false, configurable: true }); MultiFactorResolver.prototype.resolveSignIn = function (assertion) { return convertCredential(unwrap(this.auth), this.resolver.resolveSignIn(assertion)); }; return MultiFactorResolver; }()); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var User = /** @class */ (function () { function User(_delegate) { this._delegate = _delegate; this.multiFactor = exp.multiFactor(_delegate); } User.getOrCreate = function (user) { if (!User.USER_MAP.has(user)) { User.USER_MAP.set(user, new User(user)); } return User.USER_MAP.get(user); }; User.prototype.delete = function () { return this._delegate.delete(); }; User.prototype.reload = function () { return this._delegate.reload(); }; User.prototype.toJSON = function () { return this._delegate.toJSON(); }; User.prototype.getIdTokenResult = function (forceRefresh) { return this._delegate.getIdTokenResult(forceRefresh); }; User.prototype.getIdToken = function (forceRefresh) { return this._delegate.getIdToken(forceRefresh); }; User.prototype.linkAndRetrieveDataWithCredential = function (credential) { return this.linkWithCredential(credential); }; User.prototype.linkWithCredential = function (credential) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { return [2 /*return*/, convertCredential(this.auth, exp.linkWithCredential(this._delegate, credential))]; }); }); }; User.prototype.linkWithPhoneNumber = function (phoneNumber, applicationVerifier) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { return [2 /*return*/, convertConfirmationResult(this.auth, exp.linkWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier))]; }); }); }; User.prototype.linkWithPopup = function (provider) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { return [2 /*return*/, convertCredential(this.auth, exp.linkWithPopup(this._delegate, provider, CompatPopupRedirectResolver))]; }); }); }; User.prototype.linkWithRedirect = function (provider) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, _savePersistenceForRedirect(exp._castAuth(this.auth))]; case 1: _a.sent(); return [2 /*return*/, exp.linkWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)]; } }); }); }; User.prototype.reauthenticateAndRetrieveDataWithCredential = function (credential) { return this.reauthenticateWithCredential(credential); }; User.prototype.reauthenticateWithCredential = function (credential) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { return [2 /*return*/, convertCredential(this.auth, exp.reauthenticateWithCredential(this._delegate, credential))]; }); }); }; User.prototype.reauthenticateWithPhoneNumber = function (phoneNumber, applicationVerifier) { return convertConfirmationResult(this.auth, exp.reauthenticateWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier)); }; User.prototype.reauthenticateWithPopup = function (provider) { return convertCredential(this.auth, exp.reauthenticateWithPopup(this._delegate, provider, CompatPopupRedirectResolver)); }; User.prototype.reauthenticateWithRedirect = function (provider) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, _savePersistenceForRedirect(exp._castAuth(this.auth))]; case 1: _a.sent(); return [2 /*return*/, exp.reauthenticateWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)]; } }); }); }; User.prototype.sendEmailVerification = function (actionCodeSettings) { return exp.sendEmailVerification(this._delegate, actionCodeSettings); }; User.prototype.unlink = function (providerId) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: return [4 /*yield*/, exp.unlink(this._delegate, providerId)]; case 1: _a.sent(); return [2 /*return*/, this]; } }); }); }; User.prototype.updateEmail = function (newEmail) { return exp.updateEmail(this._delegate, newEmail); }; User.prototype.updatePassword = function (newPassword) { return exp.updatePassword(this._delegate, newPassword); }; User.prototype.updatePhoneNumber = function (phoneCredential) { return exp.updatePhoneNumber(this._delegate, phoneCredential); }; User.prototype.updateProfile = function (profile) { return exp.updateProfile(this._delegate, profile); }; User.prototype.verifyBeforeUpdateEmail = function (newEmail, actionCodeSettings) { return exp.verifyBeforeUpdateEmail(this._delegate, newEmail, actionCodeSettings); }; Object.defineProperty(User.prototype, "emailVerified", { get: function () { return this._delegate.emailVerified; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "isAnonymous", { get: function () { return this._delegate.isAnonymous; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "metadata", { get: function () { return this._delegate.metadata; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "phoneNumber", { get: function () { return this._delegate.phoneNumber; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "providerData", { get: function () { return this._delegate.providerData; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "refreshToken", { get: function () { return this._delegate.refreshToken; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "tenantId", { get: function () { return this._delegate.tenantId; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "displayName", { get: function () { return this._delegate.displayName; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "email", { get: function () { return this._delegate.email; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "photoURL", { get: function () { return this._delegate.photoURL; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "providerId", { get: function () { return this._delegate.providerId; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "uid", { get: function () { return this._delegate.uid; }, enumerable: false, configurable: true }); Object.defineProperty(User.prototype, "auth", { get: function () { return this._delegate.auth; }, enumerable: false, configurable: true }); // Maintain a map so that there's always a 1:1 mapping between new User and // legacy compat users User.USER_MAP = new WeakMap(); return User; }()); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var _assert$1 = exp._assert; var Auth = /** @class */ (function () { function Auth(app, provider) { this.app = app; if (provider.isInitialized()) { this._delegate = provider.getImmediate(); this.linkUnderlyingAuth(); return; } var apiKey = app.options.apiKey; // TODO: platform needs to be determined using heuristics _assert$1(apiKey, "invalid-api-key" /* exp.AuthErrorCode.INVALID_API_KEY */, { appName: app.name }); // TODO: platform needs to be determined using heuristics _assert$1(apiKey, "invalid-api-key" /* exp.AuthErrorCode.INVALID_API_KEY */, { appName: app.name }); // Only use a popup/redirect resolver in browser environments var resolver = typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined; this._delegate = provider.initialize({ options: { persistence: buildPersistenceHierarchy(apiKey, app.name), popupRedirectResolver: resolver } }); this._delegate._updateErrorMap(exp.debugErrorMap); this.linkUnderlyingAuth(); } Object.defineProperty(Auth.prototype, "emulatorConfig", { get: function () { return this._delegate.emulatorConfig; }, enumerable: false, configurable: true }); Object.defineProperty(Auth.prototype, "currentUser", { get: function () { if (!this._delegate.currentUser) { return null; } return User.getOrCreate(this._delegate.currentUser); }, enumerable: false, configurable: true }); Object.defineProperty(Auth.prototype, "languageCode", { get: function () { return this._delegate.languageCode; }, set: function (languageCode) { this._delegate.languageCode = languageCode; }, enumerable: false, configurable: true }); Object.defineProperty(Auth.prototype, "settings", { get: function () { return this._delegate.settings; }, enumerable: false, configurable: true }); Object.defineProperty(Auth.prototype, "tenantId", { get: function () { return this._delegate.tenantId; }, set: function (tid) { this._delegate.tenantId = tid; }, enumerable: false, configurable: true }); Auth.prototype.useDeviceLanguage = function () { this._delegate.useDeviceLanguage(); }; Auth.prototype.signOut = function () { return this._delegate.signOut(); }; Auth.prototype.useEmulator = function (url, options) { exp.connectAuthEmulator(this._delegate, url, options); }; Auth.prototype.applyActionCode = function (code) { return exp.applyActionCode(this._delegate, code); }; Auth.prototype.checkActionCode = function (code) { return exp.checkActionCode(this._delegate, code); }; Auth.prototype.confirmPasswordReset = function (code, newPassword) { return exp.confirmPasswordReset(this._delegate, code, newPassword); }; Auth.prototype.createUserWithEmailAndPassword = function (email, password) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { return [2 /*return*/, convertCredential(this._delegate, exp.createUserWithEmailAndPassword(this._delegate, email, password))]; }); }); }; Auth.prototype.fetchProvidersForEmail = function (email) { return this.fetchSignInMethodsForEmail(email); }; Auth.prototype.fetchSignInMethodsForEmail = function (email) { return exp.fetchSignInMethodsForEmail(this._delegate, email); }; Auth.prototype.isSignInWithEmailLink = function (emailLink) { return exp.isSignInWithEmailLink(this._delegate, emailLink); }; Auth.prototype.getRedirectResult = function () { return __awaiter(this, void 0, void 0, function () { var credential; return __generator(this, function (_a) { switch (_a.label) { case 0: _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */); return [4 /*yield*/, exp.getRedirectResult(this._delegate, CompatPopupRedirectResolver)]; case 1: credential = _a.sent(); if (!credential) { return [2 /*return*/, { credential: null, user: null }]; } return [2 /*return*/, convertCredential(this._delegate, Promise.resolve(credential))]; } }); }); }; // This function should only be called by frameworks (e.g. FirebaseUI-web) to log their usage. // It is not intended for direct use by developer apps. NO jsdoc here to intentionally leave it // out of autogenerated documentation pages to reduce accidental misuse. Auth.prototype.addFrameworkForLogging = function (framework) { exp.addFrameworkForLogging(this._delegate, framework); }; Auth.prototype.onAuthStateChanged = function (nextOrObserver, errorFn, completed) { var _a = wrapObservers(nextOrObserver, errorFn, completed), next = _a.next, error = _a.error, complete = _a.complete; return this._delegate.onAuthStateChanged(next, error, complete); }; Auth.prototype.onIdTokenChanged = function (nextOrObserver, errorFn, completed) { var _a = wrapObservers(nextOrObserver, errorFn, completed), next = _a.next, error = _a.error, complete = _a.complete; return this._delegate.onIdTokenChanged(next, error, complete); }; Auth.prototype.sendSignInLinkToEmail = function (email, actionCodeSettings) { return exp.sendSignInLinkToEmail(this._delegate, email, actionCodeSettings); }; Auth.prototype.sendPasswordResetEmail = function (email, actionCodeSettings) { return exp.sendPasswordResetEmail(this._delegate, email, actionCodeSettings || undefined); }; Auth.prototype.setPersistence = function (persistence) { return __awaiter(this, void 0, void 0, function () { var converted, _a, isIndexedDBFullySupported; return __generator(this, function (_b) { switch (_b.label) { case 0: _validatePersistenceArgument(this._delegate, persistence); _a = persistence; switch (_a) { case Persistence.SESSION: return [3 /*break*/, 1]; case Persistence.LOCAL: return [3 /*break*/, 2]; case Persistence.NONE: return [3 /*break*/, 4]; } return [3 /*break*/, 5]; case 1: converted = exp.browserSessionPersistence; return [3 /*break*/, 6]; case 2: return [4 /*yield*/, exp ._getInstance(exp.indexedDBLocalPersistence) ._isAvailable()]; case 3: isIndexedDBFullySupported = _b.sent(); converted = isIndexedDBFullySupported ? exp.indexedDBLocalPersistence : exp.browserLocalPersistence; return [3 /*break*/, 6]; case 4: converted = exp.inMemoryPersistence; return [3 /*break*/, 6]; case 5: return [2 /*return*/, exp._fail("argument-error" /* exp.AuthErrorCode.ARGUMENT_ERROR */, { appName: this._delegate.name })]; case 6: return [2 /*return*/, this._delegate.setPersistence(converted)]; } }); }); }; Auth.prototype.signInAndRetrieveDataWithCredential = function (credential) { return this.signInWithCredential(credential); }; Auth.prototype.signInAnonymously = function () { return convertCredential(this._delegate, exp.signInAnonymously(this._delegate)); }; Auth.prototype.signInWithCredential = function (credential) { return convertCredential(this._delegate, exp.signInWithCredential(this._delegate, credential)); }; Auth.prototype.signInWithCustomToken = function (token) { return convertCredential(this._delegate, exp.signInWithCustomToken(this._delegate, token)); }; Auth.prototype.signInWithEmailAndPassword = function (email, password) { return convertCredential(this._delegate, exp.signInWithEmailAndPassword(this._delegate, email, password)); }; Auth.prototype.signInWithEmailLink = function (email, emailLink) { return convertCredential(this._delegate, exp.signInWithEmailLink(this._delegate, email, emailLink)); }; Auth.prototype.signInWithPhoneNumber = function (phoneNumber, applicationVerifier) { return convertConfirmationResult(this._delegate, exp.signInWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier)); }; Auth.prototype.signInWithPopup = function (provider) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */); return [2 /*return*/, convertCredential(this._delegate, exp.signInWithPopup(this._delegate, provider, CompatPopupRedirectResolver))]; }); }); }; Auth.prototype.signInWithRedirect = function (provider) { return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) { switch (_a.label) { case 0: _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */); return [4 /*yield*/, _savePersistenceForRedirect(this._delegate)]; case 1: _a.sent(); return [2 /*return*/, exp.signInWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)]; } }); }); }; Auth.prototype.updateCurrentUser = function (user) { // remove ts-ignore once overloads are defined for exp functions to accept compat objects // @ts-ignore return this._delegate.updateCurrentUser(user); }; Auth.prototype.verifyPasswordResetCode = function (code) { return exp.verifyPasswordResetCode(this._delegate, code); }; Auth.prototype.unwrap = function () { return this._delegate; }; Auth.prototype._delete = function () { return this._delegate._delete(); }; Auth.prototype.linkUnderlyingAuth = function () { var _this = this; this._delegate.wrapped = function () { return _this; }; }; Auth.Persistence = Persistence; return Auth; }()); function wrapObservers(nextOrObserver, error, complete) { var next = nextOrObserver; if (typeof nextOrObserver !== 'function') { (next = nextOrObserver.next, error = nextOrObserver.error, complete = nextOrObserver.complete); } // We know 'next' is now a function var oldNext = next; var newNext = function (user) { return oldNext(user && User.getOrCreate(user)); }; return { next: newNext, error: error, complete: complete }; } function buildPersistenceHierarchy(apiKey, appName) { // Note this is slightly different behavior: in this case, the stored // persistence is checked *first* rather than last. This is because we want // to prefer stored persistence type in the hierarchy. This is an empty // array if window is not available or there is no pending redirect var persistences = _getPersistencesFromRedirect(apiKey, appName); // If "self" is available, add indexedDB if (typeof self !== 'undefined' && !persistences.includes(exp.indexedDBLocalPersistence)) { persistences.push(exp.indexedDBLocalPersistence); } // If "window" is available, add HTML Storage persistences if (typeof window !== 'undefined') { for (var _i = 0, _a = [ exp.browserLocalPersistence, exp.browserSessionPersistence ]; _i < _a.length; _i++) { var persistence = _a[_i]; if (!persistences.includes(persistence)) { persistences.push(persistence); } } } // Add in-memory as a final fallback if (!persistences.includes(exp.inMemoryPersistence)) { persistences.push(exp.inMemoryPersistence); } return persistences; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var PhoneAuthProvider = /** @class */ (function () { function PhoneAuthProvider() { this.providerId = 'phone'; // TODO: remove ts-ignore when moving types from auth-types to auth-compat // @ts-ignore this._delegate = new exp.PhoneAuthProvider(unwrap(firebase.auth())); } PhoneAuthProvider.credential = function (verificationId, verificationCode) { return exp.PhoneAuthProvider.credential(verificationId, verificationCode); }; PhoneAuthProvider.prototype.verifyPhoneNumber = function (phoneInfoOptions, applicationVerifier) { return this._delegate.verifyPhoneNumber( // The implementation matches but the types are subtly incompatible // eslint-disable-next-line @typescript-eslint/no-explicit-any phoneInfoOptions, applicationVerifier); }; PhoneAuthProvider.prototype.unwrap = function () { return this._delegate; }; PhoneAuthProvider.PHONE_SIGN_IN_METHOD = exp.PhoneAuthProvider.PHONE_SIGN_IN_METHOD; PhoneAuthProvider.PROVIDER_ID = exp.PhoneAuthProvider.PROVIDER_ID; return PhoneAuthProvider; }()); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var _assert = exp._assert; var RecaptchaVerifier = /** @class */ (function () { function RecaptchaVerifier(container, parameters, app) { if (app === void 0) { app = firebase.app(); } var _a; // API key is required for web client RPC calls. _assert((_a = app.options) === null || _a === void 0 ? void 0 : _a.apiKey, "invalid-api-key" /* exp.AuthErrorCode.INVALID_API_KEY */, { appName: app.name }); this._delegate = new exp.RecaptchaVerifier(container, // eslint-disable-next-line @typescript-eslint/no-explicit-any parameters, // TODO: remove ts-ignore when moving types from auth-types to auth-compat // @ts-ignore app.auth()); this.type = this._delegate.type; } RecaptchaVerifier.prototype.clear = function () { this._delegate.clear(); }; RecaptchaVerifier.prototype.render = function () { return this._delegate.render(); }; RecaptchaVerifier.prototype.verify = function () { return this._delegate.verify(); }; return RecaptchaVerifier; }()); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var AUTH_TYPE = 'auth-compat'; // Create auth components to register with firebase. // Provides Auth public APIs. function registerAuthCompat(instance) { instance.INTERNAL.registerComponent(new Component(AUTH_TYPE, function (container) { // getImmediate for FirebaseApp will always succeed var app = container.getProvider('app-compat').getImmediate(); var authProvider = container.getProvider('auth'); return new Auth(app, authProvider); }, "PUBLIC" /* ComponentType.PUBLIC */) .setServiceProps({ ActionCodeInfo: { Operation: { EMAIL_SIGNIN: exp.ActionCodeOperation.EMAIL_SIGNIN, PASSWORD_RESET: exp.ActionCodeOperation.PASSWORD_RESET, RECOVER_EMAIL: exp.ActionCodeOperation.RECOVER_EMAIL, REVERT_SECOND_FACTOR_ADDITION: exp.ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION, VERIFY_AND_CHANGE_EMAIL: exp.ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL, VERIFY_EMAIL: exp.ActionCodeOperation.VERIFY_EMAIL } }, EmailAuthProvider: exp.EmailAuthProvider, FacebookAuthProvider: exp.FacebookAuthProvider, GithubAuthProvider: exp.GithubAuthProvider, GoogleAuthProvider: exp.GoogleAuthProvider, OAuthProvider: exp.OAuthProvider, SAMLAuthProvider: exp.SAMLAuthProvider, PhoneAuthProvider: PhoneAuthProvider, PhoneMultiFactorGenerator: exp.PhoneMultiFactorGenerator, RecaptchaVerifier: RecaptchaVerifier, TwitterAuthProvider: exp.TwitterAuthProvider, Auth: Auth, AuthCredential: exp.AuthCredential, Error: FirebaseError }) .setInstantiationMode("LAZY" /* InstantiationMode.LAZY */) .setMultipleInstances(false)); instance.registerVersion(name, version); } registerAuthCompat(firebase); //# sourceMappingURL=index.esm.js.map