js • Lines: 3272'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var index = require('./index-7d302f10.js');
var util = require('@firebase/util');
var app = require('@firebase/app');
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.dbPromise = null;
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.dbPromise) {
return this.dbPromise;
}
this.dbPromise = _openDatabase();
this.dbPromise.catch(() => {
this.dbPromise = null;
});
return this.dbPromise;
}
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.dbPromise) {
const db = await this.dbPromise;
db.close();
this.dbPromise = null;
}
// 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;
}
await this._withRetries(async (db) => {
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