@firebase/app 0.7.17 → 0.7.18-20222320822

package/dist/esm/index.esm5.js

@@ -1,8 +1,9 @@
 import { Component, ComponentContainer } from '@firebase/component';
-import { __values, __assign, __awaiter, __generator } from 'tslib';
+import { __values, __assign, __awaiter, __generator, __spreadArray, __read } from 'tslib';
 import { Logger, setUserLogHandler, setLogLevel as setLogLevel$1 } from '@firebase/logger';
-import { ErrorFactory, deepEqual } from '@firebase/util';
+import { ErrorFactory, deepEqual, base64Encode, isIndexedDBAvailable, validateIndexedDBOpenable } from '@firebase/util';
 export { FirebaseError } from '@firebase/util';
+import { openDb } from 'idb';
 
 /**
  * @license
@@ -59,7 +60,7 @@ function isVersionServiceProvider(provider) {
 }
 
 var name$o = "@firebase/app";
-var version$1 = "0.7.17";
+var version$1 = "0.7.18-20222320822";
 
 /**
  * @license
@@ -126,7 +127,7 @@ var name$2 = "@firebase/firestore";
 var name$1 = "@firebase/firestore-compat";
 
 var name = "firebase";
-var version = "9.6.7";
+var version = "9.6.8-20222320822";
 
 /**
  * @license
@@ -268,6 +269,12 @@ function _registerComponent(component) {
  * @internal
  */
 function _getProvider(app, name) {
+    var heartbeatController = app.container
+        .getProvider('heartbeat')
+        .getImmediate({ optional: true });
+    if (heartbeatController) {
+        void heartbeatController.triggerHeartbeat();
+    }
     return app.container.getProvider(name);
 }
 /**
@@ -317,6 +324,10 @@ var ERRORS = (_a = {},
     _a["invalid-app-argument" /* INVALID_APP_ARGUMENT */] = 'firebase.{$appName}() takes either no argument or a ' +
         'Firebase App instance.',
     _a["invalid-log-argument" /* INVALID_LOG_ARGUMENT */] = 'First argument to `onLog` must be null or a function.',
+    _a["storage-open" /* STORAGE_OPEN */] = 'Error thrown when opening storage. Original error: {$originalErrorMessage}.',
+    _a["storage-get" /* STORAGE_GET */] = 'Error thrown when reading from storage. Original error: {$originalErrorMessage}.',
+    _a["storage-set" /* STORAGE_WRITE */] = 'Error thrown when writing to storage. Original error: {$originalErrorMessage}.',
+    _a["storage-delete" /* STORAGE_DELETE */] = 'Error thrown when deleting from storage. Original error: {$originalErrorMessage}.',
     _a);
 var ERROR_FACTORY = new ErrorFactory('app', 'Firebase', ERRORS);
 
@@ -622,6 +633,454 @@ function setLogLevel(logLevel) {
     setLogLevel$1(logLevel);
 }
 
+/**
+ * @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.
+ */
+var DB_NAME = 'firebase-heartbeat-database';
+var DB_VERSION = 1;
+var STORE_NAME = 'firebase-heartbeat-store';
+var dbPromise = null;
+function getDbPromise() {
+    if (!dbPromise) {
+        dbPromise = openDb(DB_NAME, DB_VERSION, function (upgradeDB) {
+            // We don't use 'break' in this switch statement, the fall-through
+            // behavior is what we want, because if there are multiple versions between
+            // the old version and the current version, we want ALL the migrations
+            // that correspond to those versions to run, not only the last one.
+            // eslint-disable-next-line default-case
+            switch (upgradeDB.oldVersion) {
+                case 0:
+                    upgradeDB.createObjectStore(STORE_NAME);
+            }
+        }).catch(function (e) {
+            throw ERROR_FACTORY.create("storage-open" /* STORAGE_OPEN */, {
+                originalErrorMessage: e.message
+            });
+        });
+    }
+    return dbPromise;
+}
+function readHeartbeatsFromIndexedDB(app) {
+    return __awaiter(this, void 0, void 0, function () {
+        var db, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, getDbPromise()];
+                case 1:
+                    db = _a.sent();
+                    return [2 /*return*/, db
+                            .transaction(STORE_NAME)
+                            .objectStore(STORE_NAME)
+                            .get(computeKey(app))];
+                case 2:
+                    e_1 = _a.sent();
+                    throw ERROR_FACTORY.create("storage-get" /* STORAGE_GET */, {
+                        originalErrorMessage: e_1.message
+                    });
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
+    return __awaiter(this, void 0, void 0, function () {
+        var db, tx, objectStore, e_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    return [4 /*yield*/, getDbPromise()];
+                case 1:
+                    db = _a.sent();
+                    tx = db.transaction(STORE_NAME, 'readwrite');
+                    objectStore = tx.objectStore(STORE_NAME);
+                    return [4 /*yield*/, objectStore.put(heartbeatObject, computeKey(app))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, tx.complete];
+                case 3:
+                    e_2 = _a.sent();
+                    throw ERROR_FACTORY.create("storage-set" /* STORAGE_WRITE */, {
+                        originalErrorMessage: e_2.message
+                    });
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function deleteHeartbeatsFromIndexedDB(app) {
+    return __awaiter(this, void 0, void 0, function () {
+        var db, tx, e_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    return [4 /*yield*/, getDbPromise()];
+                case 1:
+                    db = _a.sent();
+                    tx = db.transaction(STORE_NAME, 'readwrite');
+                    return [4 /*yield*/, tx.objectStore(STORE_NAME).delete(computeKey(app))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, tx.complete];
+                case 3:
+                    e_3 = _a.sent();
+                    throw ERROR_FACTORY.create("storage-delete" /* STORAGE_DELETE */, {
+                        originalErrorMessage: e_3.message
+                    });
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function computeKey(app) {
+    return app.name + "!" + app.options.appId;
+}
+
+/**
+ * @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.
+ */
+var MAX_HEADER_BYTES = 1024;
+// 30 days
+var STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1000;
+var HeartbeatServiceImpl = /** @class */ (function () {
+    function HeartbeatServiceImpl(container) {
+        var _this = this;
+        this.container = container;
+        /**
+         * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate
+         * the header string.
+         * Stores one record per date. This will be consolidated into the standard
+         * format of one record per user agent string before being sent as a header.
+         * Populated from indexedDB when the controller is instantiated and should
+         * be kept in sync with indexedDB.
+         * Leave public for easier testing.
+         */
+        this._heartbeatsCache = null;
+        var app = this.container.getProvider('app').getImmediate();
+        this._storage = new HeartbeatStorageImpl(app);
+        this._heartbeatsCachePromise = this._storage.read().then(function (result) {
+            _this._heartbeatsCache = result;
+            return result;
+        });
+    }
+    /**
+     * Called to report a heartbeat. The function will generate
+     * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
+     * to IndexedDB.
+     * Note that we only store one heartbeat per day. So if a heartbeat for today is
+     * already logged, subsequent calls to this function in the same day will be ignored.
+     */
+    HeartbeatServiceImpl.prototype.triggerHeartbeat = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var platformLogger, userAgent, date, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        platformLogger = this.container
+                            .getProvider('platform-logger')
+                            .getImmediate();
+                        userAgent = platformLogger.getPlatformInfoString();
+                        date = getUTCDateString();
+                        if (!(this._heartbeatsCache === null)) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this._heartbeatsCachePromise];
+                    case 1:
+                        _a._heartbeatsCache = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        if (this._heartbeatsCache.some(function (singleDateHeartbeat) { return singleDateHeartbeat.date === date; })) {
+                            // Do not store a heartbeat if one is already stored for this day.
+                            return [2 /*return*/];
+                        }
+                        else {
+                            // There is no entry for this date. Create one.
+                            this._heartbeatsCache.push({ date: date, userAgent: userAgent });
+                        }
+                        // Remove entries older than 30 days.
+                        this._heartbeatsCache = this._heartbeatsCache.filter(function (singleDateHeartbeat) {
+                            var hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();
+                            var now = Date.now();
+                            return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;
+                        });
+                        return [2 /*return*/, this._storage.overwrite(this._heartbeatsCache)];
+                }
+            });
+        });
+    };
+    /**
+     * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
+     * It also clears all heartbeats from memory as well as in IndexedDB.
+     *
+     * NOTE: It will read heartbeats from the heartbeatsCache, instead of from indexedDB to reduce latency
+     */
+    HeartbeatServiceImpl.prototype.getHeartbeatsHeader = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, heartbeatsToSend, unsentEntries, headerString;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this._heartbeatsCache === null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._heartbeatsCachePromise];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        // If it's still null, it's been cleared and has not been repopulated.
+                        if (this._heartbeatsCache === null) {
+                            return [2 /*return*/, ''];
+                        }
+                        _a = extractHeartbeatsForHeader(this._heartbeatsCache), heartbeatsToSend = _a.heartbeatsToSend, unsentEntries = _a.unsentEntries;
+                        headerString = base64Encode(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+                        if (!(unsentEntries.length > 0)) return [3 /*break*/, 4];
+                        // Store any unsent entries if they exist.
+                        this._heartbeatsCache = unsentEntries;
+                        // This seems more likely than deleteAll (below) to lead to some odd state
+                        // since the cache isn't empty and this will be called again on the next request,
+                        // and is probably safest if we await it.
+                        return [4 /*yield*/, this._storage.overwrite(this._heartbeatsCache)];
+                    case 3:
+                        // This seems more likely than deleteAll (below) to lead to some odd state
+                        // since the cache isn't empty and this will be called again on the next request,
+                        // and is probably safest if we await it.
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this._heartbeatsCache = null;
+                        // Do not wait for this, to reduce latency.
+                        void this._storage.deleteAll();
+                        _b.label = 5;
+                    case 5: return [2 /*return*/, headerString];
+                }
+            });
+        });
+    };
+    return HeartbeatServiceImpl;
+}());
+function getUTCDateString() {
+    var today = new Date();
+    // Returns date format 'YYYY-MM-DD'
+    return today.toISOString().substring(0, 10);
+}
+function extractHeartbeatsForHeader(heartbeatsCache, maxSize) {
+    var e_1, _a;
+    if (maxSize === void 0) { maxSize = MAX_HEADER_BYTES; }
+    // Heartbeats grouped by user agent in the standard format to be sent in
+    // the header.
+    var heartbeatsToSend = [];
+    // Single date format heartbeats that are not sent.
+    var unsentEntries = heartbeatsCache.slice();
+    var _loop_1 = function (singleDateHeartbeat) {
+        // Look for an existing entry with the same user agent.
+        var heartbeatEntry = heartbeatsToSend.find(function (hb) { return hb.userAgent === singleDateHeartbeat.userAgent; });
+        if (!heartbeatEntry) {
+            // If no entry for this user agent exists, create one.
+            heartbeatsToSend.push({
+                userAgent: singleDateHeartbeat.userAgent,
+                dates: [singleDateHeartbeat.date]
+            });
+            if (countBytes(heartbeatsToSend) > maxSize) {
+                // If the header would exceed max size, remove the added heartbeat
+                // entry and stop adding to the header.
+                heartbeatsToSend.pop();
+                return "break";
+            }
+        }
+        else {
+            heartbeatEntry.dates.push(singleDateHeartbeat.date);
+            // If the header would exceed max size, remove the added date
+            // and stop adding to the header.
+            if (countBytes(heartbeatsToSend) > maxSize) {
+                heartbeatEntry.dates.pop();
+                return "break";
+            }
+        }
+        // Pop unsent entry from queue. (Skipped if adding the entry exceeded
+        // quota and the loop breaks early.)
+        unsentEntries = unsentEntries.slice(1);
+    };
+    try {
+        for (var heartbeatsCache_1 = __values(heartbeatsCache), heartbeatsCache_1_1 = heartbeatsCache_1.next(); !heartbeatsCache_1_1.done; heartbeatsCache_1_1 = heartbeatsCache_1.next()) {
+            var singleDateHeartbeat = heartbeatsCache_1_1.value;
+            var state_1 = _loop_1(singleDateHeartbeat);
+            if (state_1 === "break")
+                break;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (heartbeatsCache_1_1 && !heartbeatsCache_1_1.done && (_a = heartbeatsCache_1.return)) _a.call(heartbeatsCache_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        heartbeatsToSend: heartbeatsToSend,
+        unsentEntries: unsentEntries
+    };
+}
+var HeartbeatStorageImpl = /** @class */ (function () {
+    function HeartbeatStorageImpl(app) {
+        this.app = app;
+        this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+    }
+    HeartbeatStorageImpl.prototype.runIndexedDBEnvironmentCheck = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!isIndexedDBAvailable()) {
+                    return [2 /*return*/, false];
+                }
+                else {
+                    return [2 /*return*/, validateIndexedDBOpenable()
+                            .then(function () { return true; })
+                            .catch(function () { return false; })];
+                }
+            });
+        });
+    };
+    /**
+     * Read all heartbeats.
+     */
+    HeartbeatStorageImpl.prototype.read = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var canUseIndexedDB, idbHeartbeatObject;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._canUseIndexedDBPromise];
+                    case 1:
+                        canUseIndexedDB = _a.sent();
+                        if (!!canUseIndexedDB) return [3 /*break*/, 2];
+                        return [2 /*return*/, []];
+                    case 2: return [4 /*yield*/, readHeartbeatsFromIndexedDB(this.app)];
+                    case 3:
+                        idbHeartbeatObject = _a.sent();
+                        return [2 /*return*/, (idbHeartbeatObject === null || idbHeartbeatObject === void 0 ? void 0 : idbHeartbeatObject.heartbeats) || []];
+                }
+            });
+        });
+    };
+    // overwrite the storage with the provided heartbeats
+    HeartbeatStorageImpl.prototype.overwrite = function (heartbeats) {
+        return __awaiter(this, void 0, void 0, function () {
+            var canUseIndexedDB;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._canUseIndexedDBPromise];
+                    case 1:
+                        canUseIndexedDB = _a.sent();
+                        if (!canUseIndexedDB) {
+                            return [2 /*return*/];
+                        }
+                        else {
+                            return [2 /*return*/, writeHeartbeatsToIndexedDB(this.app, { heartbeats: heartbeats })];
+                        }
+                }
+            });
+        });
+    };
+    // add heartbeats
+    HeartbeatStorageImpl.prototype.add = function (heartbeats) {
+        return __awaiter(this, void 0, void 0, function () {
+            var canUseIndexedDB, existingHeartbeats;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._canUseIndexedDBPromise];
+                    case 1:
+                        canUseIndexedDB = _a.sent();
+                        if (!!canUseIndexedDB) return [3 /*break*/, 2];
+                        return [2 /*return*/];
+                    case 2: return [4 /*yield*/, this.read()];
+                    case 3:
+                        existingHeartbeats = _a.sent();
+                        return [2 /*return*/, writeHeartbeatsToIndexedDB(this.app, {
+                                heartbeats: __spreadArray(__spreadArray([], __read(existingHeartbeats)), __read(heartbeats))
+                            })];
+                }
+            });
+        });
+    };
+    // delete heartbeats
+    HeartbeatStorageImpl.prototype.delete = function (heartbeats) {
+        return __awaiter(this, void 0, void 0, function () {
+            var canUseIndexedDB, existingHeartbeats;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._canUseIndexedDBPromise];
+                    case 1:
+                        canUseIndexedDB = _a.sent();
+                        if (!!canUseIndexedDB) return [3 /*break*/, 2];
+                        return [2 /*return*/];
+                    case 2: return [4 /*yield*/, this.read()];
+                    case 3:
+                        existingHeartbeats = _a.sent();
+                        return [2 /*return*/, writeHeartbeatsToIndexedDB(this.app, {
+                                heartbeats: existingHeartbeats.filter(function (existingHeartbeat) { return !heartbeats.includes(existingHeartbeat); })
+                            })];
+                }
+            });
+        });
+    };
+    // delete all heartbeats
+    HeartbeatStorageImpl.prototype.deleteAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var canUseIndexedDB;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._canUseIndexedDBPromise];
+                    case 1:
+                        canUseIndexedDB = _a.sent();
+                        if (!canUseIndexedDB) {
+                            return [2 /*return*/];
+                        }
+                        else {
+                            return [2 /*return*/, deleteHeartbeatsFromIndexedDB(this.app)];
+                        }
+                }
+            });
+        });
+    };
+    return HeartbeatStorageImpl;
+}());
+/**
+ * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped
+ * in a platform logging header JSON object, stringified, and converted
+ * to base 64.
+ */
+function countBytes(heartbeatsCache) {
+    // base64 has a restricted set of characters, all of which should be 1 byte.
+    return base64Encode(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -640,6 +1099,7 @@ function setLogLevel(logLevel) {
  */
 function registerCoreComponents(variant) {
     _registerComponent(new Component('platform-logger', function (container) { return new PlatformLoggerServiceImpl(container); }, "PRIVATE" /* PRIVATE */));
+    _registerComponent(new Component('heartbeat', function (container) { return new HeartbeatServiceImpl(container); }, "PRIVATE" /* PRIVATE */));
     // Register `app` package.
     registerVersion(name$o, version$1, variant);
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation