diff options
Diffstat (limited to 'frontend-old/node_modules/@firebase/auth/dist/rn/internal.js')
| -rw-r--r-- | frontend-old/node_modules/@firebase/auth/dist/rn/internal.js | 3266 |
1 files changed, 3266 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js b/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js new file mode 100644 index 0000000..e82ff87 --- /dev/null +++ b/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js @@ -0,0 +1,3266 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var index = require('./index-1cf32ad3.js'); +var app = require('@firebase/app'); +var util = require('@firebase/util'); +require('@firebase/component'); +require('@firebase/logger'); + +/** + * @license + * Copyright 2019 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. + */ +// There are two different browser persistence types: local and session. +// Both have the same implementation but use a different underlying storage +// object. +class BrowserPersistenceClass { + constructor(storageRetriever, type) { + this.storageRetriever = storageRetriever; + this.type = type; + } + _isAvailable() { + try { + if (!this.storage) { + return Promise.resolve(false); + } + this.storage.setItem(index.STORAGE_AVAILABLE_KEY, '1'); + this.storage.removeItem(index.STORAGE_AVAILABLE_KEY); + return Promise.resolve(true); + } + catch { + return Promise.resolve(false); + } + } + _set(key, value) { + this.storage.setItem(key, JSON.stringify(value)); + return Promise.resolve(); + } + _get(key) { + const json = this.storage.getItem(key); + return Promise.resolve(json ? JSON.parse(json) : null); + } + _remove(key) { + this.storage.removeItem(key); + return Promise.resolve(); + } + get storage() { + return this.storageRetriever(); + } +} + +/** + * @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. + */ +// The polling period in case events are not supported +const _POLLING_INTERVAL_MS$1 = 1000; +// The IE 10 localStorage cross tab synchronization delay in milliseconds +const IE10_LOCAL_STORAGE_SYNC_DELAY = 10; +class BrowserLocalPersistence extends BrowserPersistenceClass { + constructor() { + super(() => window.localStorage, "LOCAL" /* PersistenceType.LOCAL */); + this.boundEventHandler = (event, poll) => this.onStorageEvent(event, poll); + this.listeners = {}; + this.localCache = {}; + // setTimeout return value is platform specific + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.pollTimer = null; + // Whether to use polling instead of depending on window events + this.fallbackToPolling = index._isMobileBrowser(); + this._shouldAllowMigration = true; + } + forAllChangedKeys(cb) { + // Check all keys with listeners on them. + for (const key of Object.keys(this.listeners)) { + // Get value from localStorage. + const newValue = this.storage.getItem(key); + const oldValue = this.localCache[key]; + // If local map value does not match, trigger listener with storage event. + // Differentiate this simulated event from the real storage event. + if (newValue !== oldValue) { + cb(key, oldValue, newValue); + } + } + } + onStorageEvent(event, poll = false) { + // Key would be null in some situations, like when localStorage is cleared + if (!event.key) { + this.forAllChangedKeys((key, _oldValue, newValue) => { + this.notifyListeners(key, newValue); + }); + return; + } + const key = event.key; + // Check the mechanism how this event was detected. + // The first event will dictate the mechanism to be used. + if (poll) { + // Environment detects storage changes via polling. + // Remove storage event listener to prevent possible event duplication. + this.detachListener(); + } + else { + // Environment detects storage changes via storage event listener. + // Remove polling listener to prevent possible event duplication. + this.stopPolling(); + } + const triggerListeners = () => { + // Keep local map up to date in case storage event is triggered before + // poll. + const storedValue = this.storage.getItem(key); + if (!poll && this.localCache[key] === storedValue) { + // Real storage event which has already been detected, do nothing. + // This seems to trigger in some IE browsers for some reason. + return; + } + this.notifyListeners(key, storedValue); + }; + const storedValue = this.storage.getItem(key); + if (index._isIE10() && + storedValue !== event.newValue && + event.newValue !== event.oldValue) { + // IE 10 has this weird bug where a storage event would trigger with the + // correct key, oldValue and newValue but localStorage.getItem(key) does + // not yield the updated value until a few milliseconds. This ensures + // this recovers from that situation. + setTimeout(triggerListeners, IE10_LOCAL_STORAGE_SYNC_DELAY); + } + else { + triggerListeners(); + } + } + notifyListeners(key, value) { + this.localCache[key] = value; + const listeners = this.listeners[key]; + if (listeners) { + for (const listener of Array.from(listeners)) { + listener(value ? JSON.parse(value) : value); + } + } + } + startPolling() { + this.stopPolling(); + this.pollTimer = setInterval(() => { + this.forAllChangedKeys((key, oldValue, newValue) => { + this.onStorageEvent(new StorageEvent('storage', { + key, + oldValue, + newValue + }), + /* poll */ true); + }); + }, _POLLING_INTERVAL_MS$1); + } + stopPolling() { + if (this.pollTimer) { + clearInterval(this.pollTimer); + this.pollTimer = null; + } + } + attachListener() { + window.addEventListener('storage', this.boundEventHandler); + } + detachListener() { + window.removeEventListener('storage', this.boundEventHandler); + } + _addListener(key, listener) { + if (Object.keys(this.listeners).length === 0) { + // Whether browser can detect storage event when it had already been pushed to the background. + // This may happen in some mobile browsers. A localStorage change in the foreground window + // will not be detected in the background window via the storage event. + // This was detected in iOS 7.x mobile browsers + if (this.fallbackToPolling) { + this.startPolling(); + } + else { + this.attachListener(); + } + } + if (!this.listeners[key]) { + this.listeners[key] = new Set(); + // Populate the cache to avoid spuriously triggering on first poll. + this.localCache[key] = this.storage.getItem(key); + } + this.listeners[key].add(listener); + } + _removeListener(key, listener) { + if (this.listeners[key]) { + this.listeners[key].delete(listener); + if (this.listeners[key].size === 0) { + delete this.listeners[key]; + } + } + if (Object.keys(this.listeners).length === 0) { + this.detachListener(); + this.stopPolling(); + } + } + // Update local cache on base operations: + async _set(key, value) { + await super._set(key, value); + this.localCache[key] = JSON.stringify(value); + } + async _get(key) { + const value = await super._get(key); + this.localCache[key] = JSON.stringify(value); + return value; + } + async _remove(key) { + await super._remove(key); + delete this.localCache[key]; + } +} +BrowserLocalPersistence.type = 'LOCAL'; +/** + * An implementation of {@link Persistence} of type `LOCAL` using `localStorage` + * for the underlying storage. + * + * @public + */ +const browserLocalPersistence = BrowserLocalPersistence; + +/** + * @license + * Copyright 2025 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. + */ +const POLLING_INTERVAL_MS = 1000; +// Pull a cookie value from document.cookie +function getDocumentCookie(name) { + const escapedName = name.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&'); + const matcher = RegExp(`${escapedName}=([^;]+)`); + return document.cookie.match(matcher)?.[1] ?? null; +} +// Produce a sanitized cookie name from the persistence key +function getCookieName(key) { + // __HOST- doesn't work in localhost https://issues.chromium.org/issues/40196122 but it has + // desirable security properties, so lets use a different cookie name while in dev-mode. + // Already checked isSecureContext in _isAvailable, so if it's http we're hitting local. + const isDevMode = window.location.protocol === 'http:'; + return `${isDevMode ? '__dev_' : '__HOST-'}FIREBASE_${key.split(':')[3]}`; +} +class CookiePersistence { + constructor() { + this.type = "COOKIE" /* PersistenceType.COOKIE */; + this.listenerUnsubscribes = new Map(); + } + // used to get the URL to the backend to proxy to + _getFinalTarget(originalUrl) { + if (typeof window === undefined) { + return originalUrl; + } + const url = new URL(`${window.location.origin}/__cookies__`); + url.searchParams.set('finalTarget', originalUrl); + return url; + } + // To be a usable persistence method in a chain browserCookiePersistence ensures that + // prerequisites have been met, namely that we're in a secureContext, navigator and document are + // available and cookies are enabled. Not all UAs support these method, so fallback accordingly. + async _isAvailable() { + if (typeof isSecureContext === 'boolean' && !isSecureContext) { + return false; + } + if (typeof navigator === 'undefined' || typeof document === 'undefined') { + return false; + } + return navigator.cookieEnabled ?? true; + } + // Set should be a noop as we expect middleware to handle this + async _set(_key, _value) { + return; + } + // Attempt to get the cookie from cookieStore, fallback to document.cookie + async _get(key) { + if (!this._isAvailable()) { + return null; + } + const name = getCookieName(key); + if (window.cookieStore) { + const cookie = await window.cookieStore.get(name); + return cookie?.value; + } + return getDocumentCookie(name); + } + // Log out by overriding the idToken with a sentinel value of "" + async _remove(key) { + if (!this._isAvailable()) { + return; + } + // To make sure we don't hit signout over and over again, only do this operation if we need to + // with the logout sentinel value of "" this can cause race conditions. Unnecessary set-cookie + // headers will reduce CDN hit rates too. + const existingValue = await this._get(key); + if (!existingValue) { + return; + } + const name = getCookieName(key); + document.cookie = `${name}=;Max-Age=34560000;Partitioned;Secure;SameSite=Strict;Path=/;Priority=High`; + await fetch(`/__cookies__`, { method: 'DELETE' }).catch(() => undefined); + } + // Listen for cookie changes, both cookieStore and fallback to polling document.cookie + _addListener(key, listener) { + if (!this._isAvailable()) { + return; + } + const name = getCookieName(key); + if (window.cookieStore) { + const cb = ((event) => { + const changedCookie = event.changed.find(change => change.name === name); + if (changedCookie) { + listener(changedCookie.value); + } + const deletedCookie = event.deleted.find(change => change.name === name); + if (deletedCookie) { + listener(null); + } + }); + const unsubscribe = () => window.cookieStore.removeEventListener('change', cb); + this.listenerUnsubscribes.set(listener, unsubscribe); + return window.cookieStore.addEventListener('change', cb); + } + let lastValue = getDocumentCookie(name); + const interval = setInterval(() => { + const currentValue = getDocumentCookie(name); + if (currentValue !== lastValue) { + listener(currentValue); + lastValue = currentValue; + } + }, POLLING_INTERVAL_MS); + const unsubscribe = () => clearInterval(interval); + this.listenerUnsubscribes.set(listener, unsubscribe); + } + _removeListener(_key, listener) { + const unsubscribe = this.listenerUnsubscribes.get(listener); + if (!unsubscribe) { + return; + } + unsubscribe(); + this.listenerUnsubscribes.delete(listener); + } +} +CookiePersistence.type = 'COOKIE'; +/** + * An implementation of {@link Persistence} of type `COOKIE`, for use on the client side in + * applications leveraging hybrid rendering and middleware. + * + * @remarks This persistence method requires companion middleware to function, such as that provided + * by {@link https://firebaseopensource.com/projects/firebaseextended/reactfire/ | ReactFire} for + * NextJS. + * @beta + */ +const browserCookiePersistence = CookiePersistence; + +/** + * @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. + */ +class BrowserSessionPersistence extends BrowserPersistenceClass { + constructor() { + super(() => window.sessionStorage, "SESSION" /* PersistenceType.SESSION */); + } + _addListener(_key, _listener) { + // Listeners are not supported for session storage since it cannot be shared across windows + return; + } + _removeListener(_key, _listener) { + // Listeners are not supported for session storage since it cannot be shared across windows + return; + } +} +BrowserSessionPersistence.type = 'SESSION'; +/** + * An implementation of {@link Persistence} of `SESSION` using `sessionStorage` + * for the underlying storage. + * + * @public + */ +const browserSessionPersistence = BrowserSessionPersistence; + +/** + * @license + * Copyright 2019 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. + */ +/** + * Shim for Promise.allSettled, note the slightly different format of `fulfilled` vs `status`. + * + * @param promises - Array of promises to wait on. + */ +function _allSettled(promises) { + return Promise.all(promises.map(async (promise) => { + try { + const value = await promise; + return { + fulfilled: true, + value + }; + } + catch (reason) { + return { + fulfilled: false, + reason + }; + } + })); +} + +/** + * @license + * Copyright 2019 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. + */ +/** + * Interface class for receiving messages. + * + */ +class Receiver { + constructor(eventTarget) { + this.eventTarget = eventTarget; + this.handlersMap = {}; + this.boundEventHandler = this.handleEvent.bind(this); + } + /** + * Obtain an instance of a Receiver for a given event target, if none exists it will be created. + * + * @param eventTarget - An event target (such as window or self) through which the underlying + * messages will be received. + */ + static _getInstance(eventTarget) { + // The results are stored in an array since objects can't be keys for other + // objects. In addition, setting a unique property on an event target as a + // hash map key may not be allowed due to CORS restrictions. + const existingInstance = this.receivers.find(receiver => receiver.isListeningto(eventTarget)); + if (existingInstance) { + return existingInstance; + } + const newInstance = new Receiver(eventTarget); + this.receivers.push(newInstance); + return newInstance; + } + isListeningto(eventTarget) { + return this.eventTarget === eventTarget; + } + /** + * Fans out a MessageEvent to the appropriate listeners. + * + * @remarks + * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have + * finished processing. + * + * @param event - The MessageEvent. + * + */ + async handleEvent(event) { + const messageEvent = event; + const { eventId, eventType, data } = messageEvent.data; + const handlers = this.handlersMap[eventType]; + if (!handlers?.size) { + return; + } + messageEvent.ports[0].postMessage({ + status: "ack" /* _Status.ACK */, + eventId, + eventType + }); + const promises = Array.from(handlers).map(async (handler) => handler(messageEvent.origin, data)); + const response = await _allSettled(promises); + messageEvent.ports[0].postMessage({ + status: "done" /* _Status.DONE */, + eventId, + eventType, + response + }); + } + /** + * Subscribe an event handler for a particular event. + * + * @param eventType - Event name to subscribe to. + * @param eventHandler - The event handler which should receive the events. + * + */ + _subscribe(eventType, eventHandler) { + if (Object.keys(this.handlersMap).length === 0) { + this.eventTarget.addEventListener('message', this.boundEventHandler); + } + if (!this.handlersMap[eventType]) { + this.handlersMap[eventType] = new Set(); + } + this.handlersMap[eventType].add(eventHandler); + } + /** + * Unsubscribe an event handler from a particular event. + * + * @param eventType - Event name to unsubscribe from. + * @param eventHandler - Optional event handler, if none provided, unsubscribe all handlers on this event. + * + */ + _unsubscribe(eventType, eventHandler) { + if (this.handlersMap[eventType] && eventHandler) { + this.handlersMap[eventType].delete(eventHandler); + } + if (!eventHandler || this.handlersMap[eventType].size === 0) { + delete this.handlersMap[eventType]; + } + if (Object.keys(this.handlersMap).length === 0) { + this.eventTarget.removeEventListener('message', this.boundEventHandler); + } + } +} +Receiver.receivers = []; + +/** + * @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 _generateEventId(prefix = '', digits = 10) { + let random = ''; + for (let i = 0; i < digits; i++) { + random += Math.floor(Math.random() * 10); + } + return prefix + random; +} + +/** + * @license + * Copyright 2019 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. + */ +/** + * Interface for sending messages and waiting for a completion response. + * + */ +class Sender { + constructor(target) { + this.target = target; + this.handlers = new Set(); + } + /** + * Unsubscribe the handler and remove it from our tracking Set. + * + * @param handler - The handler to unsubscribe. + */ + removeMessageHandler(handler) { + if (handler.messageChannel) { + handler.messageChannel.port1.removeEventListener('message', handler.onMessage); + handler.messageChannel.port1.close(); + } + this.handlers.delete(handler); + } + /** + * Send a message to the Receiver located at {@link target}. + * + * @remarks + * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the + * receiver has had a chance to fully process the event. + * + * @param eventType - Type of event to send. + * @param data - The payload of the event. + * @param timeout - Timeout for waiting on an ACK from the receiver. + * + * @returns An array of settled promises from all the handlers that were listening on the receiver. + */ + async _send(eventType, data, timeout = 50 /* _TimeoutDuration.ACK */) { + const messageChannel = typeof MessageChannel !== 'undefined' ? new MessageChannel() : null; + if (!messageChannel) { + throw new Error("connection_unavailable" /* _MessageError.CONNECTION_UNAVAILABLE */); + } + // Node timers and browser timers return fundamentally different types. + // We don't actually care what the value is but TS won't accept unknown and + // we can't cast properly in both environments. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let completionTimer; + let handler; + return new Promise((resolve, reject) => { + const eventId = _generateEventId('', 20); + messageChannel.port1.start(); + const ackTimer = setTimeout(() => { + reject(new Error("unsupported_event" /* _MessageError.UNSUPPORTED_EVENT */)); + }, timeout); + handler = { + messageChannel, + onMessage(event) { + const messageEvent = event; + if (messageEvent.data.eventId !== eventId) { + return; + } + switch (messageEvent.data.status) { + case "ack" /* _Status.ACK */: + // The receiver should ACK first. + clearTimeout(ackTimer); + completionTimer = setTimeout(() => { + reject(new Error("timeout" /* _MessageError.TIMEOUT */)); + }, 3000 /* _TimeoutDuration.COMPLETION */); + break; + case "done" /* _Status.DONE */: + // Once the receiver's handlers are finished we will get the results. + clearTimeout(completionTimer); + resolve(messageEvent.data.response); + break; + default: + clearTimeout(ackTimer); + clearTimeout(completionTimer); + reject(new Error("invalid_response" /* _MessageError.INVALID_RESPONSE */)); + break; + } + } + }; + this.handlers.add(handler); + messageChannel.port1.addEventListener('message', handler.onMessage); + this.target.postMessage({ + eventType, + eventId, + data + }, [messageChannel.port2]); + }).finally(() => { + if (handler) { + this.removeMessageHandler(handler); + } + }); + } +} + +/** + * @license + * Copyright 2019 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. + */ +const DB_NAME = 'firebaseLocalStorageDb'; +const DB_VERSION = 1; +const DB_OBJECTSTORE_NAME = 'firebaseLocalStorage'; +const DB_DATA_KEYPATH = 'fbase_key'; +/** + * Promise wrapper for IDBRequest + * + * Unfortunately we can't cleanly extend Promise<T> since promises are not callable in ES6 + * + */ +class DBPromise { + constructor(request) { + this.request = request; + } + toPromise() { + return new Promise((resolve, reject) => { + this.request.addEventListener('success', () => { + resolve(this.request.result); + }); + this.request.addEventListener('error', () => { + reject(this.request.error); + }); + }); + } +} +function getObjectStore(db, isReadWrite) { + return db + .transaction([DB_OBJECTSTORE_NAME], isReadWrite ? 'readwrite' : 'readonly') + .objectStore(DB_OBJECTSTORE_NAME); +} +function _deleteDatabase() { + const request = indexedDB.deleteDatabase(DB_NAME); + return new DBPromise(request).toPromise(); +} +function _openDatabase() { + const request = indexedDB.open(DB_NAME, DB_VERSION); + return new Promise((resolve, reject) => { + request.addEventListener('error', () => { + reject(request.error); + }); + request.addEventListener('upgradeneeded', () => { + const db = request.result; + try { + db.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH }); + } + catch (e) { + reject(e); + } + }); + request.addEventListener('success', async () => { + const db = request.result; + // Strange bug that occurs in Firefox when multiple tabs are opened at the + // same time. The only way to recover seems to be deleting the database + // and re-initializing it. + // https://github.com/firebase/firebase-js-sdk/issues/634 + if (!db.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) { + // Need to close the database or else you get a `blocked` event + db.close(); + await _deleteDatabase(); + resolve(await _openDatabase()); + } + else { + resolve(db); + } + }); + }); +} +async function _putObject(db, key, value) { + const request = getObjectStore(db, true).put({ + [DB_DATA_KEYPATH]: key, + value + }); + return new DBPromise(request).toPromise(); +} +async function getObject(db, key) { + const request = getObjectStore(db, false).get(key); + const data = await new DBPromise(request).toPromise(); + return data === undefined ? null : data.value; +} +function _deleteObject(db, key) { + const request = getObjectStore(db, true).delete(key); + return new DBPromise(request).toPromise(); +} +const _POLLING_INTERVAL_MS = 800; +const _TRANSACTION_RETRY_COUNT = 3; +class IndexedDBLocalPersistence { + constructor() { + this.type = "LOCAL" /* PersistenceType.LOCAL */; + this._shouldAllowMigration = true; + this.listeners = {}; + this.localCache = {}; + // setTimeout return value is platform specific + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.pollTimer = null; + this.pendingWrites = 0; + this.receiver = null; + this.sender = null; + this.serviceWorkerReceiverAvailable = false; + this.activeServiceWorker = null; + // Fire & forget the service worker registration as it may never resolve + this._workerInitializationPromise = + this.initializeServiceWorkerMessaging().then(() => { }, () => { }); + } + async _openDb() { + if (this.db) { + return this.db; + } + this.db = await _openDatabase(); + return this.db; + } + async _withRetries(op) { + let numAttempts = 0; + while (true) { + try { + const db = await this._openDb(); + return await op(db); + } + catch (e) { + if (numAttempts++ > _TRANSACTION_RETRY_COUNT) { + throw e; + } + if (this.db) { + this.db.close(); + this.db = undefined; + } + // TODO: consider adding exponential backoff + } + } + } + /** + * IndexedDB events do not propagate from the main window to the worker context. We rely on a + * postMessage interface to send these events to the worker ourselves. + */ + async initializeServiceWorkerMessaging() { + return index._isWorker() ? this.initializeReceiver() : this.initializeSender(); + } + /** + * As the worker we should listen to events from the main window. + */ + async initializeReceiver() { + this.receiver = Receiver._getInstance(index._getWorkerGlobalScope()); + // Refresh from persistence if we receive a KeyChanged message. + this.receiver._subscribe("keyChanged" /* _EventType.KEY_CHANGED */, async (_origin, data) => { + const keys = await this._poll(); + return { + keyProcessed: keys.includes(data.key) + }; + }); + // Let the sender know that we are listening so they give us more timeout. + this.receiver._subscribe("ping" /* _EventType.PING */, async (_origin, _data) => { + return ["keyChanged" /* _EventType.KEY_CHANGED */]; + }); + } + /** + * As the main window, we should let the worker know when keys change (set and remove). + * + * @remarks + * {@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/ready | ServiceWorkerContainer.ready} + * may not resolve. + */ + async initializeSender() { + // Check to see if there's an active service worker. + this.activeServiceWorker = await index._getActiveServiceWorker(); + if (!this.activeServiceWorker) { + return; + } + this.sender = new Sender(this.activeServiceWorker); + // Ping the service worker to check what events they can handle. + const results = await this.sender._send("ping" /* _EventType.PING */, {}, 800 /* _TimeoutDuration.LONG_ACK */); + if (!results) { + return; + } + if (results[0]?.fulfilled && + results[0]?.value.includes("keyChanged" /* _EventType.KEY_CHANGED */)) { + this.serviceWorkerReceiverAvailable = true; + } + } + /** + * Let the worker know about a changed key, the exact key doesn't technically matter since the + * worker will just trigger a full sync anyway. + * + * @remarks + * For now, we only support one service worker per page. + * + * @param key - Storage key which changed. + */ + async notifyServiceWorker(key) { + if (!this.sender || + !this.activeServiceWorker || + index._getServiceWorkerController() !== this.activeServiceWorker) { + return; + } + try { + await this.sender._send("keyChanged" /* _EventType.KEY_CHANGED */, { key }, + // Use long timeout if receiver has previously responded to a ping from us. + this.serviceWorkerReceiverAvailable + ? 800 /* _TimeoutDuration.LONG_ACK */ + : 50 /* _TimeoutDuration.ACK */); + } + catch { + // This is a best effort approach. Ignore errors. + } + } + async _isAvailable() { + try { + if (!indexedDB) { + return false; + } + const db = await _openDatabase(); + await _putObject(db, index.STORAGE_AVAILABLE_KEY, '1'); + await _deleteObject(db, index.STORAGE_AVAILABLE_KEY); + return true; + } + catch { } + return false; + } + async _withPendingWrite(write) { + this.pendingWrites++; + try { + await write(); + } + finally { + this.pendingWrites--; + } + } + async _set(key, value) { + return this._withPendingWrite(async () => { + await this._withRetries((db) => _putObject(db, key, value)); + this.localCache[key] = value; + return this.notifyServiceWorker(key); + }); + } + async _get(key) { + const obj = (await this._withRetries((db) => getObject(db, key))); + this.localCache[key] = obj; + return obj; + } + async _remove(key) { + return this._withPendingWrite(async () => { + await this._withRetries((db) => _deleteObject(db, key)); + delete this.localCache[key]; + return this.notifyServiceWorker(key); + }); + } + async _poll() { + // TODO: check if we need to fallback if getAll is not supported + const result = await this._withRetries((db) => { + const getAllRequest = getObjectStore(db, false).getAll(); + return new DBPromise(getAllRequest).toPromise(); + }); + if (!result) { + return []; + } + // If we have pending writes in progress abort, we'll get picked up on the next poll + if (this.pendingWrites !== 0) { + return []; + } + const keys = []; + const keysInResult = new Set(); + if (result.length !== 0) { + for (const { fbase_key: key, value } of result) { + keysInResult.add(key); + if (JSON.stringify(this.localCache[key]) !== JSON.stringify(value)) { + this.notifyListeners(key, value); + keys.push(key); + } + } + } + for (const localKey of Object.keys(this.localCache)) { + if (this.localCache[localKey] && !keysInResult.has(localKey)) { + // Deleted + this.notifyListeners(localKey, null); + keys.push(localKey); + } + } + return keys; + } + notifyListeners(key, newValue) { + this.localCache[key] = newValue; + const listeners = this.listeners[key]; + if (listeners) { + for (const listener of Array.from(listeners)) { + listener(newValue); + } + } + } + startPolling() { + this.stopPolling(); + this.pollTimer = setInterval(async () => this._poll(), _POLLING_INTERVAL_MS); + } + stopPolling() { + if (this.pollTimer) { + clearInterval(this.pollTimer); + this.pollTimer = null; + } + } + _addListener(key, listener) { + if (Object.keys(this.listeners).length === 0) { + this.startPolling(); + } + if (!this.listeners[key]) { + this.listeners[key] = new Set(); + // Populate the cache to avoid spuriously triggering on first poll. + void this._get(key); // This can happen in the background async and we can return immediately. + } + this.listeners[key].add(listener); + } + _removeListener(key, listener) { + if (this.listeners[key]) { + this.listeners[key].delete(listener); + if (this.listeners[key].size === 0) { + delete this.listeners[key]; + } + } + if (Object.keys(this.listeners).length === 0) { + this.stopPolling(); + } + } +} +IndexedDBLocalPersistence.type = 'LOCAL'; +/** + * An implementation of {@link Persistence} of type `LOCAL` using `indexedDB` + * for the underlying storage. + * + * @public + */ +const indexedDBLocalPersistence = IndexedDBLocalPersistence; + +/** + * @license + * Copyright 2021 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. + */ +/** + * Chooses a popup/redirect resolver to use. This prefers the override (which + * is directly passed in), and falls back to the property set on the auth + * object. If neither are available, this function errors w/ an argument error. + */ +function _withDefaultResolver(auth, resolverOverride) { + if (resolverOverride) { + return index._getInstance(resolverOverride); + } + index._assert(auth._popupRedirectResolver, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */); + return auth._popupRedirectResolver; +} + +/** + * @license + * Copyright 2019 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. + */ +class IdpCredential extends index.AuthCredential { + constructor(params) { + super("custom" /* ProviderId.CUSTOM */, "custom" /* ProviderId.CUSTOM */); + this.params = params; + } + _getIdTokenResponse(auth) { + return index.signInWithIdp(auth, this._buildIdpRequest()); + } + _linkToIdToken(auth, idToken) { + return index.signInWithIdp(auth, this._buildIdpRequest(idToken)); + } + _getReauthenticationResolver(auth) { + return index.signInWithIdp(auth, this._buildIdpRequest()); + } + _buildIdpRequest(idToken) { + const request = { + requestUri: this.params.requestUri, + sessionId: this.params.sessionId, + postBody: this.params.postBody, + tenantId: this.params.tenantId, + pendingToken: this.params.pendingToken, + returnSecureToken: true, + returnIdpCredential: true + }; + if (idToken) { + request.idToken = idToken; + } + return request; + } +} +function _signIn(params) { + return index._signInWithCredential(params.auth, new IdpCredential(params), params.bypassAuthState); +} +function _reauth(params) { + const { auth, user } = params; + index._assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + return index._reauthenticate(user, new IdpCredential(params), params.bypassAuthState); +} +async function _link(params) { + const { auth, user } = params; + index._assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + return index._link(user, new IdpCredential(params), params.bypassAuthState); +} + +/** + * @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. + */ +/** + * Popup event manager. Handles the popup's entire lifecycle; listens to auth + * events + */ +class AbstractPopupRedirectOperation { + constructor(auth, filter, resolver, user, bypassAuthState = false) { + this.auth = auth; + this.resolver = resolver; + this.user = user; + this.bypassAuthState = bypassAuthState; + this.pendingPromise = null; + this.eventManager = null; + this.filter = Array.isArray(filter) ? filter : [filter]; + } + execute() { + return new Promise(async (resolve, reject) => { + this.pendingPromise = { resolve, reject }; + try { + this.eventManager = await this.resolver._initialize(this.auth); + await this.onExecution(); + this.eventManager.registerConsumer(this); + } + catch (e) { + this.reject(e); + } + }); + } + async onAuthEvent(event) { + const { urlResponse, sessionId, postBody, tenantId, error, type } = event; + if (error) { + this.reject(error); + return; + } + const params = { + auth: this.auth, + requestUri: urlResponse, + sessionId: sessionId, + tenantId: tenantId || undefined, + postBody: postBody || undefined, + user: this.user, + bypassAuthState: this.bypassAuthState + }; + try { + this.resolve(await this.getIdpTask(type)(params)); + } + catch (e) { + this.reject(e); + } + } + onError(error) { + this.reject(error); + } + getIdpTask(type) { + switch (type) { + case "signInViaPopup" /* AuthEventType.SIGN_IN_VIA_POPUP */: + case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */: + return _signIn; + case "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */: + case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */: + return _link; + case "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */: + case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */: + return _reauth; + default: + index._fail(this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + } + } + resolve(cred) { + index.debugAssert(this.pendingPromise, 'Pending promise was never set'); + this.pendingPromise.resolve(cred); + this.unregisterAndCleanUp(); + } + reject(error) { + index.debugAssert(this.pendingPromise, 'Pending promise was never set'); + this.pendingPromise.reject(error); + this.unregisterAndCleanUp(); + } + unregisterAndCleanUp() { + if (this.eventManager) { + this.eventManager.unregisterConsumer(this); + } + this.pendingPromise = null; + this.cleanUp(); + } +} + +/** + * @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. + */ +const _POLL_WINDOW_CLOSE_TIMEOUT = new index.Delay(2000, 10000); +/** + * Authenticates a Firebase client using a popup-based OAuth authentication flow. + * + * @remarks + * If succeeds, returns the signed in user along with the provider's credential. If sign in was + * unsuccessful, returns an error object containing additional information about the error. + * + * This method does not work in a Node.js environment or with {@link Auth} instances created with a + * {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using a popup. + * const provider = new FacebookAuthProvider(); + * const result = await signInWithPopup(auth, provider); + * + * // The signed-in user info. + * const user = result.user; + * // This gives you a Facebook Access Token. + * const credential = provider.credentialFromResult(auth, result); + * const token = credential.accessToken; + * ``` + * + * @param auth - The {@link Auth} instance. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +async function signInWithPopup(auth, provider, resolver) { + if (app._isFirebaseServerApp(auth.app)) { + return Promise.reject(index._createError(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */)); + } + const authInternal = index._castAuth(auth); + index._assertInstanceOf(auth, provider, index.FederatedAuthProvider); + const resolverInternal = _withDefaultResolver(authInternal, resolver); + const action = new PopupOperation(authInternal, "signInViaPopup" /* AuthEventType.SIGN_IN_VIA_POPUP */, provider, resolverInternal); + return action.executeNotNull(); +} +/** + * Reauthenticates the current user with the specified {@link OAuthProvider} using a pop-up based + * OAuth flow. + * + * @remarks + * If the reauthentication is successful, the returned result will contain the user and the + * provider's credential. + * + * This method does not work in a Node.js environment or on any {@link User} signed in by + * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using a popup. + * const provider = new FacebookAuthProvider(); + * const result = await signInWithPopup(auth, provider); + * // Reauthenticate using a popup. + * await reauthenticateWithPopup(result.user, provider); + * ``` + * + * @param user - The user. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +async function reauthenticateWithPopup(user, provider, resolver) { + const userInternal = util.getModularInstance(user); + if (app._isFirebaseServerApp(userInternal.auth.app)) { + return Promise.reject(index._createError(userInternal.auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */)); + } + index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider); + const resolverInternal = _withDefaultResolver(userInternal.auth, resolver); + const action = new PopupOperation(userInternal.auth, "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */, provider, resolverInternal, userInternal); + return action.executeNotNull(); +} +/** + * Links the authenticated provider to the user account using a pop-up based OAuth flow. + * + * @remarks + * If the linking is successful, the returned result will contain the user and the provider's credential. + * + * This method does not work in a Node.js environment. + * + * @example + * ```javascript + * // Sign in using some other provider. + * const result = await signInWithEmailAndPassword(auth, email, password); + * // Link using a popup. + * const provider = new FacebookAuthProvider(); + * await linkWithPopup(result.user, provider); + * ``` + * + * @param user - The user. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +async function linkWithPopup(user, provider, resolver) { + const userInternal = util.getModularInstance(user); + index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider); + const resolverInternal = _withDefaultResolver(userInternal.auth, resolver); + const action = new PopupOperation(userInternal.auth, "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */, provider, resolverInternal, userInternal); + return action.executeNotNull(); +} +/** + * Popup event manager. Handles the popup's entire lifecycle; listens to auth + * events + * + */ +class PopupOperation extends AbstractPopupRedirectOperation { + constructor(auth, filter, provider, resolver, user) { + super(auth, filter, resolver, user); + this.provider = provider; + this.authWindow = null; + this.pollId = null; + if (PopupOperation.currentPopupAction) { + PopupOperation.currentPopupAction.cancel(); + } + PopupOperation.currentPopupAction = this; + } + async executeNotNull() { + const result = await this.execute(); + index._assert(result, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + return result; + } + async onExecution() { + index.debugAssert(this.filter.length === 1, 'Popup operations only handle one event'); + const eventId = _generateEventId(); + this.authWindow = await this.resolver._openPopup(this.auth, this.provider, this.filter[0], // There's always one, see constructor + eventId); + this.authWindow.associatedEvent = eventId; + // Check for web storage support and origin validation _after_ the popup is + // loaded. These operations are slow (~1 second or so) Rather than + // waiting on them before opening the window, optimistically open the popup + // and check for storage support at the same time. If storage support is + // not available, this will cause the whole thing to reject properly. It + // will also close the popup, but since the promise has already rejected, + // the popup closed by user poll will reject into the void. + this.resolver._originValidation(this.auth).catch(e => { + this.reject(e); + }); + this.resolver._isIframeWebStorageSupported(this.auth, isSupported => { + if (!isSupported) { + this.reject(index._createError(this.auth, "web-storage-unsupported" /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */)); + } + }); + // Handle user closure. Notice this does *not* use await + this.pollUserCancellation(); + } + get eventId() { + return this.authWindow?.associatedEvent || null; + } + cancel() { + this.reject(index._createError(this.auth, "cancelled-popup-request" /* AuthErrorCode.EXPIRED_POPUP_REQUEST */)); + } + cleanUp() { + if (this.authWindow) { + this.authWindow.close(); + } + if (this.pollId) { + window.clearTimeout(this.pollId); + } + this.authWindow = null; + this.pollId = null; + PopupOperation.currentPopupAction = null; + } + pollUserCancellation() { + const poll = () => { + if (this.authWindow?.window?.closed) { + // Make sure that there is sufficient time for whatever action to + // complete. The window could have closed but the sign in network + // call could still be in flight. This is specifically true for + // Firefox or if the opener is in an iframe, in which case the oauth + // helper closes the popup. + this.pollId = window.setTimeout(() => { + this.pollId = null; + this.reject(index._createError(this.auth, "popup-closed-by-user" /* AuthErrorCode.POPUP_CLOSED_BY_USER */)); + }, 8000 /* _Timeout.AUTH_EVENT */); + return; + } + this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get()); + }; + poll(); + } +} +// Only one popup is ever shown at once. The lifecycle of the current popup +// can be managed / cancelled by the constructor. +PopupOperation.currentPopupAction = 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. + */ +const PENDING_REDIRECT_KEY = 'pendingRedirect'; +// We only get one redirect outcome for any one auth, so just store it +// in here. +const redirectOutcomeMap = new Map(); +class RedirectAction extends AbstractPopupRedirectOperation { + constructor(auth, resolver, bypassAuthState = false) { + super(auth, [ + "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */, + "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */, + "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */, + "unknown" /* AuthEventType.UNKNOWN */ + ], resolver, undefined, bypassAuthState); + this.eventId = null; + } + /** + * Override the execute function; if we already have a redirect result, then + * just return it. + */ + async execute() { + let readyOutcome = redirectOutcomeMap.get(this.auth._key()); + if (!readyOutcome) { + try { + const hasPendingRedirect = await _getAndClearPendingRedirectStatus(this.resolver, this.auth); + const result = hasPendingRedirect ? await super.execute() : null; + readyOutcome = () => Promise.resolve(result); + } + catch (e) { + readyOutcome = () => Promise.reject(e); + } + redirectOutcomeMap.set(this.auth._key(), readyOutcome); + } + // If we're not bypassing auth state, the ready outcome should be set to + // null. + if (!this.bypassAuthState) { + redirectOutcomeMap.set(this.auth._key(), () => Promise.resolve(null)); + } + return readyOutcome(); + } + async onAuthEvent(event) { + if (event.type === "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */) { + return super.onAuthEvent(event); + } + else if (event.type === "unknown" /* AuthEventType.UNKNOWN */) { + // This is a sentinel value indicating there's no pending redirect + this.resolve(null); + return; + } + if (event.eventId) { + const user = await this.auth._redirectUserForId(event.eventId); + if (user) { + this.user = user; + return super.onAuthEvent(event); + } + else { + this.resolve(null); + } + } + } + async onExecution() { } + cleanUp() { } +} +async function _getAndClearPendingRedirectStatus(resolver, auth) { + const key = pendingRedirectKey(auth); + const persistence = resolverPersistence(resolver); + if (!(await persistence._isAvailable())) { + return false; + } + const hasPendingRedirect = (await persistence._get(key)) === 'true'; + await persistence._remove(key); + return hasPendingRedirect; +} +async function _setPendingRedirectStatus(resolver, auth) { + return resolverPersistence(resolver)._set(pendingRedirectKey(auth), 'true'); +} +function _clearRedirectOutcomes() { + redirectOutcomeMap.clear(); +} +function _overrideRedirectResult(auth, result) { + redirectOutcomeMap.set(auth._key(), result); +} +function resolverPersistence(resolver) { + return index._getInstance(resolver._redirectPersistence); +} +function pendingRedirectKey(auth) { + return index._persistenceKeyName(PENDING_REDIRECT_KEY, auth.config.apiKey, auth.name); +} + +/** + * @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. + */ +/** + * Authenticates a Firebase client using a full-page redirect flow. + * + * @remarks + * To handle the results and errors for this operation, refer to {@link getRedirectResult}. + * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices + * | best practices} when using {@link signInWithRedirect}. + * + * This method does not work in a Node.js environment or with {@link Auth} instances created with a + * {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using a redirect. + * const provider = new FacebookAuthProvider(); + * // You can add additional scopes to the provider: + * provider.addScope('user_birthday'); + * // Start a sign in process for an unauthenticated user. + * await signInWithRedirect(auth, provider); + * // This will trigger a full page redirect away from your app + * + * // After returning from the redirect when your app initializes you can obtain the result + * const result = await getRedirectResult(auth); + * if (result) { + * // This is the signed-in user + * const user = result.user; + * // This gives you a Facebook Access Token. + * const credential = provider.credentialFromResult(auth, result); + * const token = credential.accessToken; + * } + * // As this API can be used for sign-in, linking and reauthentication, + * // check the operationType to determine what triggered this redirect + * // operation. + * const operationType = result.operationType; + * ``` + * + * @param auth - The {@link Auth} instance. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +function signInWithRedirect(auth, provider, resolver) { + return _signInWithRedirect(auth, provider, resolver); +} +async function _signInWithRedirect(auth, provider, resolver) { + if (app._isFirebaseServerApp(auth.app)) { + return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(auth)); + } + const authInternal = index._castAuth(auth); + index._assertInstanceOf(auth, provider, index.FederatedAuthProvider); + // Wait for auth initialization to complete, this will process pending redirects and clear the + // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new + // redirect and creating a PENDING_REDIRECT_KEY entry. + await authInternal._initializationPromise; + const resolverInternal = _withDefaultResolver(authInternal, resolver); + await _setPendingRedirectStatus(resolverInternal, authInternal); + return resolverInternal._openRedirect(authInternal, provider, "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */); +} +/** + * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow. + * @remarks + * To handle the results and errors for this operation, refer to {@link getRedirectResult}. + * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices + * | best practices} when using {@link reauthenticateWithRedirect}. + * + * This method does not work in a Node.js environment or with {@link Auth} instances + * created with a {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using a redirect. + * const provider = new FacebookAuthProvider(); + * const result = await signInWithRedirect(auth, provider); + * // This will trigger a full page redirect away from your app + * + * // After returning from the redirect when your app initializes you can obtain the result + * const result = await getRedirectResult(auth); + * // Reauthenticate using a redirect. + * await reauthenticateWithRedirect(result.user, provider); + * // This will again trigger a full page redirect away from your app + * + * // After returning from the redirect when your app initializes you can obtain the result + * const result = await getRedirectResult(auth); + * ``` + * + * @param user - The user. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +function reauthenticateWithRedirect(user, provider, resolver) { + return _reauthenticateWithRedirect(user, provider, resolver); +} +async function _reauthenticateWithRedirect(user, provider, resolver) { + const userInternal = util.getModularInstance(user); + index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider); + if (app._isFirebaseServerApp(userInternal.auth.app)) { + return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(userInternal.auth)); + } + // Wait for auth initialization to complete, this will process pending redirects and clear the + // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new + // redirect and creating a PENDING_REDIRECT_KEY entry. + await userInternal.auth._initializationPromise; + // Allow the resolver to error before persisting the redirect user + const resolverInternal = _withDefaultResolver(userInternal.auth, resolver); + await _setPendingRedirectStatus(resolverInternal, userInternal.auth); + const eventId = await prepareUserForRedirect(userInternal); + return resolverInternal._openRedirect(userInternal.auth, provider, "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */, eventId); +} +/** + * Links the {@link OAuthProvider} to the user account using a full-page redirect flow. + * @remarks + * To handle the results and errors for this operation, refer to {@link getRedirectResult}. + * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices + * | best practices} when using {@link linkWithRedirect}. + * + * This method does not work in a Node.js environment or with {@link Auth} instances + * created with a {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using some other provider. + * const result = await signInWithEmailAndPassword(auth, email, password); + * // Link using a redirect. + * const provider = new FacebookAuthProvider(); + * await linkWithRedirect(result.user, provider); + * // This will trigger a full page redirect away from your app + * + * // After returning from the redirect when your app initializes you can obtain the result + * const result = await getRedirectResult(auth); + * ``` + * + * @param user - The user. + * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}. + * Non-OAuth providers like {@link EmailAuthProvider} will throw an error. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +function linkWithRedirect(user, provider, resolver) { + return _linkWithRedirect(user, provider, resolver); +} +async function _linkWithRedirect(user, provider, resolver) { + const userInternal = util.getModularInstance(user); + index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider); + // Wait for auth initialization to complete, this will process pending redirects and clear the + // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new + // redirect and creating a PENDING_REDIRECT_KEY entry. + await userInternal.auth._initializationPromise; + // Allow the resolver to error before persisting the redirect user + const resolverInternal = _withDefaultResolver(userInternal.auth, resolver); + await index._assertLinkedStatus(false, userInternal, provider.providerId); + await _setPendingRedirectStatus(resolverInternal, userInternal.auth); + const eventId = await prepareUserForRedirect(userInternal); + return resolverInternal._openRedirect(userInternal.auth, provider, "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */, eventId); +} +/** + * Returns a {@link UserCredential} from the redirect-based sign-in flow. + * + * @remarks + * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an + * error. If no redirect operation was called, returns `null`. + * + * This method does not work in a Node.js environment or with {@link Auth} instances created with a + * {@link @firebase/app#FirebaseServerApp}. + * + * @example + * ```javascript + * // Sign in using a redirect. + * const provider = new FacebookAuthProvider(); + * // You can add additional scopes to the provider: + * provider.addScope('user_birthday'); + * // Start a sign in process for an unauthenticated user. + * await signInWithRedirect(auth, provider); + * // This will trigger a full page redirect away from your app + * + * // After returning from the redirect when your app initializes you can obtain the result + * const result = await getRedirectResult(auth); + * if (result) { + * // This is the signed-in user + * const user = result.user; + * // This gives you a Facebook Access Token. + * const credential = provider.credentialFromResult(auth, result); + * const token = credential.accessToken; + * } + * // As this API can be used for sign-in, linking and reauthentication, + * // check the operationType to determine what triggered this redirect + * // operation. + * const operationType = result.operationType; + * ``` + * + * @param auth - The {@link Auth} instance. + * @param resolver - An instance of {@link PopupRedirectResolver}, optional + * if already supplied to {@link initializeAuth} or provided by {@link getAuth}. + * + * @public + */ +async function getRedirectResult(auth, resolver) { + await index._castAuth(auth)._initializationPromise; + return _getRedirectResult(auth, resolver, false); +} +async function _getRedirectResult(auth, resolverExtern, bypassAuthState = false) { + if (app._isFirebaseServerApp(auth.app)) { + return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(auth)); + } + const authInternal = index._castAuth(auth); + const resolver = _withDefaultResolver(authInternal, resolverExtern); + const action = new RedirectAction(authInternal, resolver, bypassAuthState); + const result = await action.execute(); + if (result && !bypassAuthState) { + delete result.user._redirectEventId; + await authInternal._persistUserIfCurrent(result.user); + await authInternal._setRedirectUser(null, resolverExtern); + } + return result; +} +async function prepareUserForRedirect(user) { + const eventId = _generateEventId(`${user.uid}:::`); + user._redirectEventId = eventId; + await user.auth._setRedirectUser(user); + await user.auth._persistUserIfCurrent(user); + return eventId; +} + +/** + * @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. + */ +// The amount of time to store the UIDs of seen events; this is +// set to 10 min by default +const EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1000; +class AuthEventManager { + constructor(auth) { + this.auth = auth; + this.cachedEventUids = new Set(); + this.consumers = new Set(); + this.queuedRedirectEvent = null; + this.hasHandledPotentialRedirect = false; + this.lastProcessedEventTime = Date.now(); + } + registerConsumer(authEventConsumer) { + this.consumers.add(authEventConsumer); + if (this.queuedRedirectEvent && + this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)) { + this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer); + this.saveEventToCache(this.queuedRedirectEvent); + this.queuedRedirectEvent = null; + } + } + unregisterConsumer(authEventConsumer) { + this.consumers.delete(authEventConsumer); + } + onEvent(event) { + // Check if the event has already been handled + if (this.hasEventBeenHandled(event)) { + return false; + } + let handled = false; + this.consumers.forEach(consumer => { + if (this.isEventForConsumer(event, consumer)) { + handled = true; + this.sendToConsumer(event, consumer); + this.saveEventToCache(event); + } + }); + if (this.hasHandledPotentialRedirect || !isRedirectEvent(event)) { + // If we've already seen a redirect before, or this is a popup event, + // bail now + return handled; + } + this.hasHandledPotentialRedirect = true; + // If the redirect wasn't handled, hang on to it + if (!handled) { + this.queuedRedirectEvent = event; + handled = true; + } + return handled; + } + sendToConsumer(event, consumer) { + if (event.error && !isNullRedirectEvent(event)) { + const code = event.error.code?.split('auth/')[1] || + "internal-error" /* AuthErrorCode.INTERNAL_ERROR */; + consumer.onError(index._createError(this.auth, code)); + } + else { + consumer.onAuthEvent(event); + } + } + isEventForConsumer(event, consumer) { + const eventIdMatches = consumer.eventId === null || + (!!event.eventId && event.eventId === consumer.eventId); + return consumer.filter.includes(event.type) && eventIdMatches; + } + hasEventBeenHandled(event) { + if (Date.now() - this.lastProcessedEventTime >= + EVENT_DUPLICATION_CACHE_DURATION_MS) { + this.cachedEventUids.clear(); + } + return this.cachedEventUids.has(eventUid(event)); + } + saveEventToCache(event) { + this.cachedEventUids.add(eventUid(event)); + this.lastProcessedEventTime = Date.now(); + } +} +function eventUid(e) { + return [e.type, e.eventId, e.sessionId, e.tenantId].filter(v => v).join('-'); +} +function isNullRedirectEvent({ type, error }) { + return (type === "unknown" /* AuthEventType.UNKNOWN */ && + error?.code === `auth/${"no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */}`); +} +function isRedirectEvent(event) { + switch (event.type) { + case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */: + case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */: + case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */: + return true; + case "unknown" /* AuthEventType.UNKNOWN */: + return isNullRedirectEvent(event); + default: + return false; + } +} + +/** + * @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. + */ +async function _getProjectConfig(auth, request = {}) { + return index._performApiRequest(auth, "GET" /* HttpMethod.GET */, "/v1/projects" /* Endpoint.GET_PROJECT_CONFIG */, request); +} + +/** + * @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. + */ +const IP_ADDRESS_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/; +const HTTP_REGEX = /^https?/; +async function _validateOrigin$1(auth) { + // Skip origin validation if we are in an emulated environment + if (auth.config.emulator) { + return; + } + const { authorizedDomains } = await _getProjectConfig(auth); + for (const domain of authorizedDomains) { + try { + if (matchDomain(domain)) { + return; + } + } + catch { + // Do nothing if there's a URL error; just continue searching + } + } + // In the old SDK, this error also provides helpful messages. + index._fail(auth, "unauthorized-domain" /* AuthErrorCode.INVALID_ORIGIN */); +} +function matchDomain(expected) { + const currentUrl = index._getCurrentUrl(); + const { protocol, hostname } = new URL(currentUrl); + if (expected.startsWith('chrome-extension://')) { + const ceUrl = new URL(expected); + if (ceUrl.hostname === '' && hostname === '') { + // For some reason we're not parsing chrome URLs properly + return (protocol === 'chrome-extension:' && + expected.replace('chrome-extension://', '') === + currentUrl.replace('chrome-extension://', '')); + } + return protocol === 'chrome-extension:' && ceUrl.hostname === hostname; + } + if (!HTTP_REGEX.test(protocol)) { + return false; + } + if (IP_ADDRESS_REGEX.test(expected)) { + // The domain has to be exactly equal to the pattern, as an IP domain will + // only contain the IP, no extra character. + return hostname === expected; + } + // Dots in pattern should be escaped. + const escapedDomainPattern = expected.replace(/\./g, '\\.'); + // Non ip address domains. + // domain.com = *.domain.com OR domain.com + const re = new RegExp('^(.+\\.' + escapedDomainPattern + '|' + escapedDomainPattern + ')$', 'i'); + return re.test(hostname); +} + +/** + * @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. + */ +const NETWORK_TIMEOUT = new index.Delay(30000, 60000); +/** + * Reset unloaded GApi modules. If gapi.load fails due to a network error, + * it will stop working after a retrial. This is a hack to fix this issue. + */ +function resetUnloadedGapiModules() { + // Clear last failed gapi.load state to force next gapi.load to first + // load the failed gapi.iframes module. + // Get gapix.beacon context. + const beacon = index._window().___jsl; + // Get current hint. + if (beacon?.H) { + // Get gapi hint. + for (const hint of Object.keys(beacon.H)) { + // Requested modules. + beacon.H[hint].r = beacon.H[hint].r || []; + // Loaded modules. + beacon.H[hint].L = beacon.H[hint].L || []; + // Set requested modules to a copy of the loaded modules. + beacon.H[hint].r = [...beacon.H[hint].L]; + // Clear pending callbacks. + if (beacon.CP) { + for (let i = 0; i < beacon.CP.length; i++) { + // Remove all failed pending callbacks. + beacon.CP[i] = null; + } + } + } + } +} +function loadGapi(auth) { + return new Promise((resolve, reject) => { + // Function to run when gapi.load is ready. + function loadGapiIframe() { + // The developer may have tried to previously run gapi.load and failed. + // Run this to fix that. + resetUnloadedGapiModules(); + gapi.load('gapi.iframes', { + callback: () => { + resolve(gapi.iframes.getContext()); + }, + ontimeout: () => { + // The above reset may be sufficient, but having this reset after + // failure ensures that if the developer calls gapi.load after the + // connection is re-established and before another attempt to embed + // the iframe, it would work and would not be broken because of our + // failed attempt. + // Timeout when gapi.iframes.Iframe not loaded. + resetUnloadedGapiModules(); + reject(index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */)); + }, + timeout: NETWORK_TIMEOUT.get() + }); + } + if (index._window().gapi?.iframes?.Iframe) { + // If gapi.iframes.Iframe available, resolve. + resolve(gapi.iframes.getContext()); + } + else if (!!index._window().gapi?.load) { + // Gapi loader ready, load gapi.iframes. + loadGapiIframe(); + } + else { + // Create a new iframe callback when this is called so as not to overwrite + // any previous defined callback. This happens if this method is called + // multiple times in parallel and could result in the later callback + // overwriting the previous one. This would end up with a iframe + // timeout. + const cbName = index._generateCallbackName('iframefcb'); + // GApi loader not available, dynamically load platform.js. + index._window()[cbName] = () => { + // GApi loader should be ready. + if (!!gapi.load) { + loadGapiIframe(); + } + else { + // Gapi loader failed, throw error. + reject(index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */)); + } + }; + // Load GApi loader. + return index._loadJS(`${index._gapiScriptUrl()}?onload=${cbName}`) + .catch(e => reject(e)); + } + }).catch(error => { + // Reset cached promise to allow for retrial. + cachedGApiLoader = null; + throw error; + }); +} +let cachedGApiLoader = null; +function _loadGapi(auth) { + cachedGApiLoader = cachedGApiLoader || loadGapi(auth); + return cachedGApiLoader; +} + +/** + * @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. + */ +const PING_TIMEOUT = new index.Delay(5000, 15000); +const IFRAME_PATH = '__/auth/iframe'; +const EMULATED_IFRAME_PATH = 'emulator/auth/iframe'; +const IFRAME_ATTRIBUTES = { + style: { + position: 'absolute', + top: '-100px', + width: '1px', + height: '1px' + }, + 'aria-hidden': 'true', + tabindex: '-1' +}; +// Map from apiHost to endpoint ID for passing into iframe. In current SDK, apiHost can be set to +// anything (not from a list of endpoints with IDs as in legacy), so this is the closest we can get. +const EID_FROM_APIHOST = new Map([ + ["identitytoolkit.googleapis.com" /* DefaultConfig.API_HOST */, 'p'], // production + ['staging-identitytoolkit.sandbox.googleapis.com', 's'], // staging + ['test-identitytoolkit.sandbox.googleapis.com', 't'] // test +]); +function getIframeUrl(auth) { + const config = auth.config; + index._assert(config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */); + const url = config.emulator + ? index._emulatorUrl(config, EMULATED_IFRAME_PATH) + : `https://${auth.config.authDomain}/${IFRAME_PATH}`; + const params = { + apiKey: config.apiKey, + appName: auth.name, + v: app.SDK_VERSION + }; + const eid = EID_FROM_APIHOST.get(auth.config.apiHost); + if (eid) { + params.eid = eid; + } + const frameworks = auth._getFrameworks(); + if (frameworks.length) { + params.fw = frameworks.join(','); + } + return `${url}?${util.querystring(params).slice(1)}`; +} +async function _openIframe(auth) { + const context = await _loadGapi(auth); + const gapi = index._window().gapi; + index._assert(gapi, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + return context.open({ + where: document.body, + url: getIframeUrl(auth), + messageHandlersFilter: gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER, + attributes: IFRAME_ATTRIBUTES, + dontclear: true + }, (iframe) => new Promise(async (resolve, reject) => { + await iframe.restyle({ + // Prevent iframe from closing on mouse out. + setHideOnLeave: false + }); + const networkError = index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */); + // Confirm iframe is correctly loaded. + // To fallback on failure, set a timeout. + const networkErrorTimer = index._window().setTimeout(() => { + reject(networkError); + }, PING_TIMEOUT.get()); + // Clear timer and resolve pending iframe ready promise. + function clearTimerAndResolve() { + index._window().clearTimeout(networkErrorTimer); + resolve(iframe); + } + // This returns an IThenable. However the reject part does not call + // when the iframe is not loaded. + iframe.ping(clearTimerAndResolve).then(clearTimerAndResolve, () => { + reject(networkError); + }); + })); +} + +/** + * @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. + */ +const BASE_POPUP_OPTIONS = { + location: 'yes', + resizable: 'yes', + statusbar: 'yes', + toolbar: 'no' +}; +const DEFAULT_WIDTH = 500; +const DEFAULT_HEIGHT = 600; +const TARGET_BLANK = '_blank'; +const FIREFOX_EMPTY_URL = 'http://localhost'; +class AuthPopup { + constructor(window) { + this.window = window; + this.associatedEvent = null; + } + close() { + if (this.window) { + try { + this.window.close(); + } + catch (e) { } + } + } +} +function _open(auth, url, name, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT) { + const top = Math.max((window.screen.availHeight - height) / 2, 0).toString(); + const left = Math.max((window.screen.availWidth - width) / 2, 0).toString(); + let target = ''; + const options = { + ...BASE_POPUP_OPTIONS, + width: width.toString(), + height: height.toString(), + top, + left + }; + // Chrome iOS 7 and 8 is returning an undefined popup win when target is + // specified, even though the popup is not necessarily blocked. + const ua = util.getUA().toLowerCase(); + if (name) { + target = index._isChromeIOS(ua) ? TARGET_BLANK : name; + } + if (index._isFirefox(ua)) { + // Firefox complains when invalid URLs are popped out. Hacky way to bypass. + url = url || FIREFOX_EMPTY_URL; + // Firefox disables by default scrolling on popup windows, which can create + // issues when the user has many Google accounts, for instance. + options.scrollbars = 'yes'; + } + const optionsString = Object.entries(options).reduce((accum, [key, value]) => `${accum}${key}=${value},`, ''); + if (index._isIOSStandalone(ua) && target !== '_self') { + openAsNewWindowIOS(url || '', target); + return new AuthPopup(null); + } + // about:blank getting sanitized causing browsers like IE/Edge to display + // brief error message before redirecting to handler. + const newWin = window.open(url || '', target, optionsString); + index._assert(newWin, auth, "popup-blocked" /* AuthErrorCode.POPUP_BLOCKED */); + // Flaky on IE edge, encapsulate with a try and catch. + try { + newWin.focus(); + } + catch (e) { } + return new AuthPopup(newWin); +} +function openAsNewWindowIOS(url, target) { + const el = document.createElement('a'); + el.href = url; + el.target = target; + const click = document.createEvent('MouseEvent'); + click.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 1, null); + el.dispatchEvent(click); +} + +/** + * @license + * Copyright 2021 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. + */ +/** + * URL for Authentication widget which will initiate the OAuth handshake + * + * @internal + */ +const WIDGET_PATH = '__/auth/handler'; +/** + * URL for emulated environment + * + * @internal + */ +const EMULATOR_WIDGET_PATH = 'emulator/auth/handler'; +/** + * Fragment name for the App Check token that gets passed to the widget + * + * @internal + */ +const FIREBASE_APP_CHECK_FRAGMENT_ID = encodeURIComponent('fac'); +async function _getRedirectUrl(auth, provider, authType, redirectUrl, eventId, additionalParams) { + index._assert(auth.config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */); + index._assert(auth.config.apiKey, auth, "invalid-api-key" /* AuthErrorCode.INVALID_API_KEY */); + const params = { + apiKey: auth.config.apiKey, + appName: auth.name, + authType, + redirectUrl, + v: app.SDK_VERSION, + eventId + }; + if (provider instanceof index.FederatedAuthProvider) { + provider.setDefaultLanguage(auth.languageCode); + params.providerId = provider.providerId || ''; + if (!util.isEmpty(provider.getCustomParameters())) { + params.customParameters = JSON.stringify(provider.getCustomParameters()); + } + // TODO set additionalParams from the provider as well? + for (const [key, value] of Object.entries(additionalParams || {})) { + params[key] = value; + } + } + if (provider instanceof index.BaseOAuthProvider) { + const scopes = provider.getScopes().filter(scope => scope !== ''); + if (scopes.length > 0) { + params.scopes = scopes.join(','); + } + } + if (auth.tenantId) { + params.tid = auth.tenantId; + } + // TODO: maybe set eid as endpointId + // TODO: maybe set fw as Frameworks.join(",") + const paramsDict = params; + for (const key of Object.keys(paramsDict)) { + if (paramsDict[key] === undefined) { + delete paramsDict[key]; + } + } + // Sets the App Check token to pass to the widget + const appCheckToken = await auth._getAppCheckToken(); + const appCheckTokenFragment = appCheckToken + ? `#${FIREBASE_APP_CHECK_FRAGMENT_ID}=${encodeURIComponent(appCheckToken)}` + : ''; + // Start at index 1 to skip the leading '&' in the query string + return `${getHandlerBase(auth)}?${util.querystring(paramsDict).slice(1)}${appCheckTokenFragment}`; +} +function getHandlerBase({ config }) { + if (!config.emulator) { + return `https://${config.authDomain}/${WIDGET_PATH}`; + } + return index._emulatorUrl(config, EMULATOR_WIDGET_PATH); +} + +/** + * @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. + */ +/** + * The special web storage event + * + */ +const WEB_STORAGE_SUPPORT_KEY = 'webStorageSupport'; +class BrowserPopupRedirectResolver { + constructor() { + this.eventManagers = {}; + this.iframes = {}; + this.originValidationPromises = {}; + this._redirectPersistence = browserSessionPersistence; + this._completeRedirectFn = _getRedirectResult; + this._overrideRedirectResult = _overrideRedirectResult; + } + // Wrapping in async even though we don't await anywhere in order + // to make sure errors are raised as promise rejections + async _openPopup(auth, provider, authType, eventId) { + index.debugAssert(this.eventManagers[auth._key()]?.manager, '_initialize() not called before _openPopup()'); + const url = await _getRedirectUrl(auth, provider, authType, index._getCurrentUrl(), eventId); + return _open(auth, url, _generateEventId()); + } + async _openRedirect(auth, provider, authType, eventId) { + await this._originValidation(auth); + const url = await _getRedirectUrl(auth, provider, authType, index._getCurrentUrl(), eventId); + index._setWindowLocation(url); + return new Promise(() => { }); + } + _initialize(auth) { + const key = auth._key(); + if (this.eventManagers[key]) { + const { manager, promise } = this.eventManagers[key]; + if (manager) { + return Promise.resolve(manager); + } + else { + index.debugAssert(promise, 'If manager is not set, promise should be'); + return promise; + } + } + const promise = this.initAndGetManager(auth); + this.eventManagers[key] = { promise }; + // If the promise is rejected, the key should be removed so that the + // operation can be retried later. + promise.catch(() => { + delete this.eventManagers[key]; + }); + return promise; + } + async initAndGetManager(auth) { + const iframe = await _openIframe(auth); + const manager = new AuthEventManager(auth); + iframe.register('authEvent', (iframeEvent) => { + index._assert(iframeEvent?.authEvent, auth, "invalid-auth-event" /* AuthErrorCode.INVALID_AUTH_EVENT */); + // TODO: Consider splitting redirect and popup events earlier on + const handled = manager.onEvent(iframeEvent.authEvent); + return { status: handled ? "ACK" /* GapiOutcome.ACK */ : "ERROR" /* GapiOutcome.ERROR */ }; + }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER); + this.eventManagers[auth._key()] = { manager }; + this.iframes[auth._key()] = iframe; + return manager; + } + _isIframeWebStorageSupported(auth, cb) { + const iframe = this.iframes[auth._key()]; + iframe.send(WEB_STORAGE_SUPPORT_KEY, { type: WEB_STORAGE_SUPPORT_KEY }, result => { + const isSupported = result?.[0]?.[WEB_STORAGE_SUPPORT_KEY]; + if (isSupported !== undefined) { + cb(!!isSupported); + } + index._fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER); + } + _originValidation(auth) { + const key = auth._key(); + if (!this.originValidationPromises[key]) { + this.originValidationPromises[key] = _validateOrigin$1(auth); + } + return this.originValidationPromises[key]; + } + get _shouldInitProactively() { + // Mobile browsers and Safari need to optimistically initialize + return index._isMobileBrowser() || index._isSafari() || index._isIOS(); + } +} +/** + * An implementation of {@link PopupRedirectResolver} suitable for browser + * based applications. + * + * @remarks + * This method does not work in a Node.js environment. + * + * @public + */ +const browserPopupRedirectResolver = BrowserPopupRedirectResolver; + +/** + * @license + * Copyright 2021 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. + */ +const DEFAULT_ID_TOKEN_MAX_AGE = 5 * 60; +const authIdTokenMaxAge = util.getExperimentalSetting('authIdTokenMaxAge') || DEFAULT_ID_TOKEN_MAX_AGE; +let lastPostedIdToken = null; +const mintCookieFactory = (url) => async (user) => { + const idTokenResult = user && (await user.getIdTokenResult()); + const idTokenAge = idTokenResult && + (new Date().getTime() - Date.parse(idTokenResult.issuedAtTime)) / 1000; + if (idTokenAge && idTokenAge > authIdTokenMaxAge) { + return; + } + // Specifically trip null => undefined when logged out, to delete any existing cookie + const idToken = idTokenResult?.token; + if (lastPostedIdToken === idToken) { + return; + } + lastPostedIdToken = idToken; + await fetch(url, { + method: idToken ? 'POST' : 'DELETE', + headers: idToken + ? { + 'Authorization': `Bearer ${idToken}` + } + : {} + }); +}; +/** + * Returns the Auth instance associated with the provided {@link @firebase/app#FirebaseApp}. + * If no instance exists, initializes an Auth instance with platform-specific default dependencies. + * + * @param app - The Firebase App. + * + * @public + */ +function getAuth(app$1 = app.getApp()) { + const provider = app._getProvider(app$1, 'auth'); + if (provider.isInitialized()) { + return provider.getImmediate(); + } + const auth = index.initializeAuth(app$1, { + popupRedirectResolver: browserPopupRedirectResolver, + persistence: [ + indexedDBLocalPersistence, + browserLocalPersistence, + browserSessionPersistence + ] + }); + const authTokenSyncPath = util.getExperimentalSetting('authTokenSyncURL'); + // Only do the Cookie exchange in a secure context + if (authTokenSyncPath && + typeof isSecureContext === 'boolean' && + isSecureContext) { + // Don't allow urls (XSS possibility), only paths on the same domain + const authTokenSyncUrl = new URL(authTokenSyncPath, location.origin); + if (location.origin === authTokenSyncUrl.origin) { + const mintCookie = mintCookieFactory(authTokenSyncUrl.toString()); + index.beforeAuthStateChanged(auth, mintCookie, () => mintCookie(auth.currentUser)); + index.onIdTokenChanged(auth, user => mintCookie(user)); + } + } + const authEmulatorHost = util.getDefaultEmulatorHost('auth'); + if (authEmulatorHost) { + index.connectAuthEmulator(auth, `http://${authEmulatorHost}`); + } + return auth; +} +function getScriptParentElement() { + return document.getElementsByTagName('head')?.[0] ?? document; +} +index._setExternalJSProvider({ + loadJS(url) { + // TODO: consider adding timeout support & cancellation + return new Promise((resolve, reject) => { + const el = document.createElement('script'); + el.setAttribute('src', url); + el.onload = resolve; + el.onerror = e => { + const error = index._createError("internal-error" /* AuthErrorCode.INTERNAL_ERROR */); + error.customData = e; + reject(error); + }; + el.type = 'text/javascript'; + el.charset = 'UTF-8'; + getScriptParentElement().appendChild(el); + }); + }, + gapiScript: 'https://apis.google.com/js/api.js', + recaptchaV2Script: 'https://www.google.com/recaptcha/api.js', + recaptchaEnterpriseScript: 'https://www.google.com/recaptcha/enterprise.js?render=' +}); +index.registerAuth("Browser" /* ClientPlatform.BROWSER */); + +/** + * @license + * Copyright 2021 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 _cordovaWindow() { + return window; +} + +/** + * @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. + */ +/** + * How long to wait after the app comes back into focus before concluding that + * the user closed the sign in tab. + */ +const REDIRECT_TIMEOUT_MS = 2000; +/** + * Generates the URL for the OAuth handler. + */ +async function _generateHandlerUrl(auth, event, provider) { + // Get the cordova plugins + const { BuildInfo } = _cordovaWindow(); + index.debugAssert(event.sessionId, 'AuthEvent did not contain a session ID'); + const sessionDigest = await computeSha256(event.sessionId); + const additionalParams = {}; + if (index._isIOS()) { + // iOS app identifier + additionalParams['ibi'] = BuildInfo.packageName; + } + else if (index._isAndroid()) { + // Android app identifier + additionalParams['apn'] = BuildInfo.packageName; + } + else { + index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */); + } + // Add the display name if available + if (BuildInfo.displayName) { + additionalParams['appDisplayName'] = BuildInfo.displayName; + } + // Attached the hashed session ID + additionalParams['sessionId'] = sessionDigest; + return _getRedirectUrl(auth, provider, event.type, undefined, event.eventId ?? undefined, additionalParams); +} +/** + * Validates that this app is valid for this project configuration + */ +async function _validateOrigin(auth) { + const { BuildInfo } = _cordovaWindow(); + const request = {}; + if (index._isIOS()) { + request.iosBundleId = BuildInfo.packageName; + } + else if (index._isAndroid()) { + request.androidPackageName = BuildInfo.packageName; + } + else { + index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */); + } + // Will fail automatically if package name is not authorized + await _getProjectConfig(auth, request); +} +function _performRedirect(handlerUrl) { + // Get the cordova plugins + const { cordova } = _cordovaWindow(); + return new Promise(resolve => { + cordova.plugins.browsertab.isAvailable(browserTabIsAvailable => { + let iabRef = null; + if (browserTabIsAvailable) { + cordova.plugins.browsertab.openUrl(handlerUrl); + } + else { + // TODO: Return the inappbrowser ref that's returned from the open call + iabRef = cordova.InAppBrowser.open(handlerUrl, index._isIOS7Or8() ? '_blank' : '_system', 'location=yes'); + } + resolve(iabRef); + }); + }); +} +/** + * This function waits for app activity to be seen before resolving. It does + * this by attaching listeners to various dom events. Once the app is determined + * to be visible, this promise resolves. AFTER that resolution, the listeners + * are detached and any browser tabs left open will be closed. + */ +async function _waitForAppResume(auth, eventListener, iabRef) { + // Get the cordova plugins + const { cordova } = _cordovaWindow(); + let cleanup = () => { }; + try { + await new Promise((resolve, reject) => { + let onCloseTimer = null; + // DEFINE ALL THE CALLBACKS ===== + function authEventSeen() { + // Auth event was detected. Resolve this promise and close the extra + // window if it's still open. + resolve(); + const closeBrowserTab = cordova.plugins.browsertab?.close; + if (typeof closeBrowserTab === 'function') { + closeBrowserTab(); + } + // Close inappbrowser embedded webview in iOS7 and 8 case if still + // open. + if (typeof iabRef?.close === 'function') { + iabRef.close(); + } + } + function resumed() { + if (onCloseTimer) { + // This code already ran; do not rerun. + return; + } + onCloseTimer = window.setTimeout(() => { + // Wait two seconds after resume then reject. + reject(index._createError(auth, "redirect-cancelled-by-user" /* AuthErrorCode.REDIRECT_CANCELLED_BY_USER */)); + }, REDIRECT_TIMEOUT_MS); + } + function visibilityChanged() { + if (document?.visibilityState === 'visible') { + resumed(); + } + } + // ATTACH ALL THE LISTENERS ===== + // Listen for the auth event + eventListener.addPassiveListener(authEventSeen); + // Listen for resume and visibility events + document.addEventListener('resume', resumed, false); + if (index._isAndroid()) { + document.addEventListener('visibilitychange', visibilityChanged, false); + } + // SETUP THE CLEANUP FUNCTION ===== + cleanup = () => { + eventListener.removePassiveListener(authEventSeen); + document.removeEventListener('resume', resumed, false); + document.removeEventListener('visibilitychange', visibilityChanged, false); + if (onCloseTimer) { + window.clearTimeout(onCloseTimer); + } + }; + }); + } + finally { + cleanup(); + } +} +/** + * Checks the configuration of the Cordova environment. This has no side effect + * if the configuration is correct; otherwise it throws an error with the + * missing plugin. + */ +function _checkCordovaConfiguration(auth) { + const win = _cordovaWindow(); + // Check all dependencies installed. + // https://github.com/nordnet/cordova-universal-links-plugin + // Note that cordova-universal-links-plugin has been abandoned. + // A fork with latest fixes is available at: + // https://www.npmjs.com/package/cordova-universal-links-plugin-fix + index._assert(typeof win?.universalLinks?.subscribe === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, { + missingPlugin: 'cordova-universal-links-plugin-fix' + }); + // https://www.npmjs.com/package/cordova-plugin-buildinfo + index._assert(typeof win?.BuildInfo?.packageName !== 'undefined', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, { + missingPlugin: 'cordova-plugin-buildInfo' + }); + // https://github.com/google/cordova-plugin-browsertab + index._assert(typeof win?.cordova?.plugins?.browsertab?.openUrl === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, { + missingPlugin: 'cordova-plugin-browsertab' + }); + index._assert(typeof win?.cordova?.plugins?.browsertab?.isAvailable === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, { + missingPlugin: 'cordova-plugin-browsertab' + }); + // https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-inappbrowser/ + index._assert(typeof win?.cordova?.InAppBrowser?.open === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, { + missingPlugin: 'cordova-plugin-inappbrowser' + }); +} +/** + * Computes the SHA-256 of a session ID. The SubtleCrypto interface is only + * available in "secure" contexts, which covers Cordova (which is served on a file + * protocol). + */ +async function computeSha256(sessionId) { + const bytes = stringToArrayBuffer(sessionId); + // TODO: For IE11 crypto has a different name and this operation comes back + // as an object, not a promise. This is the old proposed standard that + // is used by IE11: + // https://www.w3.org/TR/2013/WD-WebCryptoAPI-20130108/#cryptooperation-interface + const buf = await crypto.subtle.digest('SHA-256', bytes); + const arr = Array.from(new Uint8Array(buf)); + return arr.map(num => num.toString(16).padStart(2, '0')).join(''); +} +function stringToArrayBuffer(str) { + // This function is only meant to deal with an ASCII charset and makes + // certain simplifying assumptions. + index.debugAssert(/[0-9a-zA-Z]+/.test(str), 'Can only convert alpha-numeric strings'); + if (typeof TextEncoder !== 'undefined') { + return new TextEncoder().encode(str); + } + const buff = new ArrayBuffer(str.length); + const view = new Uint8Array(buff); + for (let i = 0; i < str.length; i++) { + view[i] = str.charCodeAt(i); + } + return view; +} + +/** + * @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. + */ +const SESSION_ID_LENGTH = 20; +/** Custom AuthEventManager that adds passive listeners to events */ +class CordovaAuthEventManager extends AuthEventManager { + constructor() { + super(...arguments); + this.passiveListeners = new Set(); + this.initPromise = new Promise(resolve => { + this.resolveInitialized = resolve; + }); + } + addPassiveListener(cb) { + this.passiveListeners.add(cb); + } + removePassiveListener(cb) { + this.passiveListeners.delete(cb); + } + // In a Cordova environment, this manager can live through multiple redirect + // operations + resetRedirect() { + this.queuedRedirectEvent = null; + this.hasHandledPotentialRedirect = false; + } + /** Override the onEvent method */ + onEvent(event) { + this.resolveInitialized(); + this.passiveListeners.forEach(cb => cb(event)); + return super.onEvent(event); + } + async initialized() { + await this.initPromise; + } +} +/** + * Generates a (partial) {@link AuthEvent}. + */ +function _generateNewEvent(auth, type, eventId = null) { + return { + type, + eventId, + urlResponse: null, + sessionId: generateSessionId(), + postBody: null, + tenantId: auth.tenantId, + error: index._createError(auth, "no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */) + }; +} +function _savePartialEvent(auth, event) { + return storage()._set(persistenceKey(auth), event); +} +async function _getAndRemoveEvent(auth) { + const event = (await storage()._get(persistenceKey(auth))); + if (event) { + await storage()._remove(persistenceKey(auth)); + } + return event; +} +function _eventFromPartialAndUrl(partialEvent, url) { + // Parse the deep link within the dynamic link URL. + const callbackUrl = _getDeepLinkFromCallback(url); + // Confirm it is actually a callback URL. + // Currently the universal link will be of this format: + // https://<AUTH_DOMAIN>/__/auth/callback<OAUTH_RESPONSE> + // This is a fake URL but is not intended to take the user anywhere + // and just redirect to the app. + if (callbackUrl.includes('/__/auth/callback')) { + // Check if there is an error in the URL. + // This mechanism is also used to pass errors back to the app: + // https://<AUTH_DOMAIN>/__/auth/callback?firebaseError=<STRINGIFIED_ERROR> + const params = searchParamsOrEmpty(callbackUrl); + // Get the error object corresponding to the stringified error if found. + const errorObject = params['firebaseError'] + ? parseJsonOrNull(decodeURIComponent(params['firebaseError'])) + : null; + const code = errorObject?.['code']?.split('auth/')?.[1]; + const error = code ? index._createError(code) : null; + if (error) { + return { + type: partialEvent.type, + eventId: partialEvent.eventId, + tenantId: partialEvent.tenantId, + error, + urlResponse: null, + sessionId: null, + postBody: null + }; + } + else { + return { + type: partialEvent.type, + eventId: partialEvent.eventId, + tenantId: partialEvent.tenantId, + sessionId: partialEvent.sessionId, + urlResponse: callbackUrl, + postBody: null + }; + } + } + return null; +} +function generateSessionId() { + const chars = []; + const allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'; + for (let i = 0; i < SESSION_ID_LENGTH; i++) { + const idx = Math.floor(Math.random() * allowedChars.length); + chars.push(allowedChars.charAt(idx)); + } + return chars.join(''); +} +function storage() { + return index._getInstance(browserLocalPersistence); +} +function persistenceKey(auth) { + return index._persistenceKeyName("authEvent" /* KeyName.AUTH_EVENT */, auth.config.apiKey, auth.name); +} +function parseJsonOrNull(json) { + try { + return JSON.parse(json); + } + catch (e) { + return null; + } +} +// Exported for testing +function _getDeepLinkFromCallback(url) { + const params = searchParamsOrEmpty(url); + const link = params['link'] ? decodeURIComponent(params['link']) : undefined; + // Double link case (automatic redirect) + const doubleDeepLink = searchParamsOrEmpty(link)['link']; + // iOS custom scheme links. + const iOSDeepLink = params['deep_link_id'] + ? decodeURIComponent(params['deep_link_id']) + : undefined; + const iOSDoubleDeepLink = searchParamsOrEmpty(iOSDeepLink)['link']; + return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url; +} +/** + * Optimistically tries to get search params from a string, or else returns an + * empty search params object. + */ +function searchParamsOrEmpty(url) { + if (!url?.includes('?')) { + return {}; + } + const [_, ...rest] = url.split('?'); + return util.querystringDecode(rest.join('?')); +} + +/** + * @license + * Copyright 2021 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. + */ +/** + * How long to wait for the initial auth event before concluding no + * redirect pending + */ +const INITIAL_EVENT_TIMEOUT_MS = 500; +class CordovaPopupRedirectResolver { + constructor() { + this._redirectPersistence = browserSessionPersistence; + this._shouldInitProactively = true; // This is lightweight for Cordova + this.eventManagers = new Map(); + this.originValidationPromises = {}; + this._completeRedirectFn = _getRedirectResult; + this._overrideRedirectResult = _overrideRedirectResult; + } + async _initialize(auth) { + const key = auth._key(); + let manager = this.eventManagers.get(key); + if (!manager) { + manager = new CordovaAuthEventManager(auth); + this.eventManagers.set(key, manager); + this.attachCallbackListeners(auth, manager); + } + return manager; + } + _openPopup(auth) { + index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */); + } + async _openRedirect(auth, provider, authType, eventId) { + _checkCordovaConfiguration(auth); + const manager = await this._initialize(auth); + await manager.initialized(); + // Reset the persisted redirect states. This does not matter on Web where + // the redirect always blows away application state entirely. On Cordova, + // the app maintains control flow through the redirect. + manager.resetRedirect(); + _clearRedirectOutcomes(); + await this._originValidation(auth); + const event = _generateNewEvent(auth, authType, eventId); + await _savePartialEvent(auth, event); + const url = await _generateHandlerUrl(auth, event, provider); + const iabRef = await _performRedirect(url); + return _waitForAppResume(auth, manager, iabRef); + } + _isIframeWebStorageSupported(_auth, _cb) { + throw new Error('Method not implemented.'); + } + _originValidation(auth) { + const key = auth._key(); + if (!this.originValidationPromises[key]) { + this.originValidationPromises[key] = _validateOrigin(auth); + } + return this.originValidationPromises[key]; + } + attachCallbackListeners(auth, manager) { + // Get the global plugins + const { universalLinks, handleOpenURL, BuildInfo } = _cordovaWindow(); + const noEventTimeout = setTimeout(async () => { + // We didn't see that initial event. Clear any pending object and + // dispatch no event + await _getAndRemoveEvent(auth); + manager.onEvent(generateNoEvent()); + }, INITIAL_EVENT_TIMEOUT_MS); + const universalLinksCb = async (eventData) => { + // We have an event so we can clear the no event timeout + clearTimeout(noEventTimeout); + const partialEvent = await _getAndRemoveEvent(auth); + let finalEvent = null; + if (partialEvent && eventData?.['url']) { + finalEvent = _eventFromPartialAndUrl(partialEvent, eventData['url']); + } + // If finalEvent is never filled, trigger with no event + manager.onEvent(finalEvent || generateNoEvent()); + }; + // Universal links subscriber doesn't exist for iOS, so we need to check + if (typeof universalLinks !== 'undefined' && + typeof universalLinks.subscribe === 'function') { + universalLinks.subscribe(null, universalLinksCb); + } + // iOS 7 or 8 custom URL schemes. + // This is also the current default behavior for iOS 9+. + // For this to work, cordova-plugin-customurlscheme needs to be installed. + // https://github.com/EddyVerbruggen/Custom-URL-scheme + // Do not overwrite the existing developer's URL handler. + const existingHandleOpenURL = handleOpenURL; + const packagePrefix = `${BuildInfo.packageName.toLowerCase()}://`; + _cordovaWindow().handleOpenURL = async (url) => { + if (url.toLowerCase().startsWith(packagePrefix)) { + // We want this intentionally to float + // eslint-disable-next-line @typescript-eslint/no-floating-promises + universalLinksCb({ url }); + } + // Call the developer's handler if it is present. + if (typeof existingHandleOpenURL === 'function') { + try { + existingHandleOpenURL(url); + } + catch (e) { + // This is a developer error. Don't stop the flow of the SDK. + console.error(e); + } + } + }; + } +} +/** + * An implementation of {@link PopupRedirectResolver} suitable for Cordova + * based applications. + * + * @public + */ +const cordovaPopupRedirectResolver = CordovaPopupRedirectResolver; +function generateNoEvent() { + return { + type: "unknown" /* AuthEventType.UNKNOWN */, + eventId: null, + sessionId: null, + urlResponse: null, + postBody: null, + tenantId: null, + error: index._createError("no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */) + }; +} + +/** + * @license + * Copyright 2017 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. + */ +// 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. +function addFrameworkForLogging(auth, framework) { + index._castAuth(auth)._logFramework(framework); +} + +exports.ActionCodeOperation = index.ActionCodeOperation; +exports.ActionCodeURL = index.ActionCodeURL; +exports.AuthCredential = index.AuthCredential; +exports.AuthErrorCodes = index.AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY; +exports.AuthImpl = index.AuthImpl; +exports.EmailAuthCredential = index.EmailAuthCredential; +exports.EmailAuthProvider = index.EmailAuthProvider; +exports.FacebookAuthProvider = index.FacebookAuthProvider; +exports.FactorId = index.FactorId; +exports.FetchProvider = index.FetchProvider; +exports.GithubAuthProvider = index.GithubAuthProvider; +exports.GoogleAuthProvider = index.GoogleAuthProvider; +exports.OAuthCredential = index.OAuthCredential; +exports.OAuthProvider = index.OAuthProvider; +exports.OperationType = index.OperationType; +exports.PhoneAuthCredential = index.PhoneAuthCredential; +exports.PhoneAuthProvider = index.PhoneAuthProvider; +exports.PhoneMultiFactorGenerator = index.PhoneMultiFactorGenerator; +exports.ProviderId = index.ProviderId; +exports.RecaptchaVerifier = index.RecaptchaVerifier; +exports.SAMLAuthCredential = index.SAMLAuthCredential; +exports.SAMLAuthProvider = index.SAMLAuthProvider; +exports.SignInMethod = index.SignInMethod; +exports.TotpMultiFactorGenerator = index.TotpMultiFactorGenerator; +exports.TotpSecret = index.TotpSecret; +exports.TwitterAuthProvider = index.TwitterAuthProvider; +exports.UserImpl = index.UserImpl; +exports._assert = index._assert; +exports._castAuth = index._castAuth; +exports._fail = index._fail; +exports._getClientVersion = index._getClientVersion; +exports._getInstance = index._getInstance; +exports._persistenceKeyName = index._persistenceKeyName; +exports.applyActionCode = index.applyActionCode; +exports.beforeAuthStateChanged = index.beforeAuthStateChanged; +exports.checkActionCode = index.checkActionCode; +exports.confirmPasswordReset = index.confirmPasswordReset; +exports.connectAuthEmulator = index.connectAuthEmulator; +exports.createUserWithEmailAndPassword = index.createUserWithEmailAndPassword; +exports.debugErrorMap = index.debugErrorMap; +exports.deleteUser = index.deleteUser; +exports.fetchSignInMethodsForEmail = index.fetchSignInMethodsForEmail; +exports.getAdditionalUserInfo = index.getAdditionalUserInfo; +exports.getIdToken = index.getIdToken; +exports.getIdTokenResult = index.getIdTokenResult; +exports.getMultiFactorResolver = index.getMultiFactorResolver; +exports.inMemoryPersistence = index.inMemoryPersistence; +exports.initializeAuth = index.initializeAuth; +exports.initializeRecaptchaConfig = index.initializeRecaptchaConfig; +exports.isSignInWithEmailLink = index.isSignInWithEmailLink; +exports.linkWithCredential = index.linkWithCredential; +exports.linkWithPhoneNumber = index.linkWithPhoneNumber; +exports.multiFactor = index.multiFactor; +exports.onAuthStateChanged = index.onAuthStateChanged; +exports.onIdTokenChanged = index.onIdTokenChanged; +exports.parseActionCodeURL = index.parseActionCodeURL; +exports.prodErrorMap = index.prodErrorMap; +exports.reauthenticateWithCredential = index.reauthenticateWithCredential; +exports.reauthenticateWithPhoneNumber = index.reauthenticateWithPhoneNumber; +exports.reload = index.reload; +exports.revokeAccessToken = index.revokeAccessToken; +exports.sendEmailVerification = index.sendEmailVerification; +exports.sendPasswordResetEmail = index.sendPasswordResetEmail; +exports.sendSignInLinkToEmail = index.sendSignInLinkToEmail; +exports.setPersistence = index.setPersistence; +exports.signInAnonymously = index.signInAnonymously; +exports.signInWithCredential = index.signInWithCredential; +exports.signInWithCustomToken = index.signInWithCustomToken; +exports.signInWithEmailAndPassword = index.signInWithEmailAndPassword; +exports.signInWithEmailLink = index.signInWithEmailLink; +exports.signInWithPhoneNumber = index.signInWithPhoneNumber; +exports.signOut = index.signOut; +exports.unlink = index.unlink; +exports.updateCurrentUser = index.updateCurrentUser; +exports.updateEmail = index.updateEmail; +exports.updatePassword = index.updatePassword; +exports.updatePhoneNumber = index.updatePhoneNumber; +exports.updateProfile = index.updateProfile; +exports.useDeviceLanguage = index.useDeviceLanguage; +exports.validatePassword = index.validatePassword; +exports.verifyBeforeUpdateEmail = index.verifyBeforeUpdateEmail; +exports.verifyPasswordResetCode = index.verifyPasswordResetCode; +exports.AuthPopup = AuthPopup; +exports._generateEventId = _generateEventId; +exports._getRedirectResult = _getRedirectResult; +exports._overrideRedirectResult = _overrideRedirectResult; +exports.addFrameworkForLogging = addFrameworkForLogging; +exports.browserCookiePersistence = browserCookiePersistence; +exports.browserLocalPersistence = browserLocalPersistence; +exports.browserPopupRedirectResolver = browserPopupRedirectResolver; +exports.browserSessionPersistence = browserSessionPersistence; +exports.cordovaPopupRedirectResolver = cordovaPopupRedirectResolver; +exports.getAuth = getAuth; +exports.getRedirectResult = getRedirectResult; +exports.indexedDBLocalPersistence = indexedDBLocalPersistence; +exports.linkWithPopup = linkWithPopup; +exports.linkWithRedirect = linkWithRedirect; +exports.reauthenticateWithPopup = reauthenticateWithPopup; +exports.reauthenticateWithRedirect = reauthenticateWithRedirect; +exports.signInWithPopup = signInWithPopup; +exports.signInWithRedirect = signInWithRedirect; +//# sourceMappingURL=internal.js.map |
