@firebase/firestore 1.14.0-canary.daf63c2c → 1.14.0

package/dist/index.node.cjs.js

@@ -14670,11 +14670,22 @@ var IndexedDbPersistence = /** @class */ (function () {
         }
     };
     IndexedDbPersistence.createIndexedDbPersistence = function (options) {
-        if (!IndexedDbPersistence.isAvailable()) {
-            throw new FirestoreError(Code.UNIMPLEMENTED, UNSUPPORTED_PLATFORM_ERROR_MSG);
-        }
-        var persistence = new IndexedDbPersistence(options.allowTabSynchronization, options.persistenceKey, options.clientId, options.platform, options.lruParams, options.queue, options.serializer, options.sequenceNumberSyncer);
-        return persistence;
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var persistence;
+            return tslib.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!IndexedDbPersistence.isAvailable()) {
+                            throw new FirestoreError(Code.UNIMPLEMENTED, UNSUPPORTED_PLATFORM_ERROR_MSG);
+                        }
+                        persistence = new IndexedDbPersistence(options.allowTabSynchronization, options.persistenceKey, options.clientId, options.platform, options.lruParams, options.queue, options.serializer, options.sequenceNumberSyncer);
+                        return [4 /*yield*/, persistence.start()];
+                    case 1:
+                        _c.sent();
+                        return [2 /*return*/, persistence];
+                }
+            });
+        });
     };
     /**
      * Attempt to start IndexedDb persistence.
@@ -16031,9 +16042,6 @@ var MemoryPersistence = /** @class */ (function () {
         this.indexManager = new MemoryIndexManager();
         this.remoteDocumentCache = new MemoryRemoteDocumentCache(this.indexManager, sizer);
     }
-    MemoryPersistence.prototype.start = function () {
-        return Promise.resolve();
-    };
     MemoryPersistence.prototype.shutdown = function () {
         // No durable state to ensure is closed on shutdown.
         this._started = false;
@@ -16221,44 +16229,61 @@ var MemoryEagerDelegate = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE = 'You are using the memory-only build of Firestore. Persistence support is ' +
-    'only available via the @firebase/firestore bundle or the ' +
-    'firebase-firestore.js build.';
 /**
- * Provides all components needed for Firestore with in-memory persistence.
- * Uses EagerGC garbage collection.
+ * Provides all components needed for Firestore with IndexedDB persistence.
  */
-var MemoryComponentProvider = /** @class */ (function () {
-    function MemoryComponentProvider() {
+var IndexedDbComponentProvider = /** @class */ (function () {
+    function IndexedDbComponentProvider() {
     }
-    MemoryComponentProvider.prototype.initialize = function (cfg) {
+    IndexedDbComponentProvider.prototype.initialize = function (asyncQueue, databaseInfo, platform, datastore, clientId, initialUser, maxConcurrentLimboResolutions, persistenceSettings) {
         return tslib.__awaiter(this, void 0, void 0, function () {
+            var persistenceKey, serializer, _c, garbageCollector;
             var _this = this;
-            return tslib.__generator(this, function (_c) {
-                switch (_c.label) {
+            return tslib.__generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        this.sharedClientState = this.createSharedClientState(cfg);
-                        this.persistence = this.createPersistence(cfg);
-                        return [4 /*yield*/, this.persistence.start()];
-                    case 1:
-                        _c.sent();
-                        this.gcScheduler = this.createGarbageCollectionScheduler(cfg);
-                        this.localStore = this.createLocalStore(cfg);
-                        this.remoteStore = this.createRemoteStore(cfg);
-                        this.syncEngine = this.createSyncEngine(cfg);
-                        this.eventManager = this.createEventManager(cfg);
+                        debugAssert(persistenceSettings.durable, 'IndexedDbComponentProvider can only provide durable persistence');
+                        debugAssert(!this.sharedClientState, 'initialize() already called');
+                        persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
+                        serializer = platform.newSerializer(databaseInfo.databaseId);
+                        if (!WebStorageSharedClientState.isAvailable(platform)) {
+                            throw new FirestoreError(Code.UNIMPLEMENTED, 'IndexedDB persistence is only available on platforms that support LocalStorage.');
+                        }
+                        this.sharedClientState = persistenceSettings.synchronizeTabs
+                            ? new WebStorageSharedClientState(asyncQueue, platform, persistenceKey, clientId, initialUser)
+                            : new MemorySharedClientState();
                         this.sharedClientState.onlineStateHandler = function (onlineState) { return _this.syncEngine.applyOnlineStateChange(onlineState, 1 /* SharedClientState */); };
+                        _c = this;
+                        return [4 /*yield*/, IndexedDbPersistence.createIndexedDbPersistence({
+                                allowTabSynchronization: persistenceSettings.synchronizeTabs,
+                                persistenceKey: persistenceKey,
+                                clientId: clientId,
+                                platform: platform,
+                                queue: asyncQueue,
+                                serializer: serializer,
+                                lruParams: LruParams.withCacheSize(persistenceSettings.cacheSizeBytes),
+                                sequenceNumberSyncer: this.sharedClientState
+                            })];
+                    case 1:
+                        _c.persistence = _d.sent();
+                        garbageCollector = this.persistence.referenceDelegate
+                            .garbageCollector;
+                        this.gcScheduler = new LruScheduler(garbageCollector, asyncQueue);
+                        this.localStore = new LocalStore(this.persistence, new IndexFreeQueryEngine(), initialUser);
+                        this.remoteStore = new RemoteStore(this.localStore, datastore, asyncQueue, function (onlineState) { return _this.syncEngine.applyOnlineStateChange(onlineState, 0 /* RemoteStore */); }, platform.newConnectivityMonitor());
+                        this.syncEngine = new SyncEngine(this.localStore, this.remoteStore, this.sharedClientState, initialUser, maxConcurrentLimboResolutions);
+                        this.eventManager = new EventManager(this.syncEngine);
                         this.remoteStore.syncEngine = this.syncEngine;
                         this.sharedClientState.syncEngine = this.syncEngine;
                         return [4 /*yield*/, this.sharedClientState.start()];
                     case 2:
-                        _c.sent();
+                        _d.sent();
                         return [4 /*yield*/, this.remoteStore.start()];
                     case 3:
-                        _c.sent();
+                        _d.sent();
                         return [4 /*yield*/, this.localStore.start()];
                     case 4:
-                        _c.sent();
+                        _d.sent();
                         // NOTE: This will immediately call the listener, so we make sure to
                         // set it after localStore / remoteStore are started.
                         return [4 /*yield*/, this.persistence.setPrimaryStateListener(function (isPrimary) { return tslib.__awaiter(_this, void 0, void 0, function () {
@@ -16267,13 +16292,11 @@ var MemoryComponentProvider = /** @class */ (function () {
                                         case 0: return [4 /*yield*/, this.syncEngine.applyPrimaryState(isPrimary)];
                                         case 1:
                                             _c.sent();
-                                            if (this.gcScheduler) {
-                                                if (isPrimary && !this.gcScheduler.started) {
-                                                    this.gcScheduler.start(this.localStore);
-                                                }
-                                                else if (!isPrimary) {
-                                                    this.gcScheduler.stop();
-                                                }
+                                            if (isPrimary && !this.gcScheduler.started) {
+                                                this.gcScheduler.start(this.localStore);
+                                            }
+                                            else if (!isPrimary) {
+                                                this.gcScheduler.stop();
                                             }
                                             return [2 /*return*/];
                                     }
@@ -16282,86 +16305,65 @@ var MemoryComponentProvider = /** @class */ (function () {
                     case 5:
                         // NOTE: This will immediately call the listener, so we make sure to
                         // set it after localStore / remoteStore are started.
-                        _c.sent();
+                        _d.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
-    MemoryComponentProvider.prototype.createEventManager = function (cfg) {
-        return new EventManager(this.syncEngine);
-    };
-    MemoryComponentProvider.prototype.createGarbageCollectionScheduler = function (cfg) {
-        return null;
-    };
-    MemoryComponentProvider.prototype.createLocalStore = function (cfg) {
-        return new LocalStore(this.persistence, new IndexFreeQueryEngine(), cfg.initialUser);
-    };
-    MemoryComponentProvider.prototype.createPersistence = function (cfg) {
-        debugAssert(!cfg.persistenceSettings.durable, 'Can only start memory persistence');
-        return new MemoryPersistence(cfg.clientId, MemoryEagerDelegate.factory);
-    };
-    MemoryComponentProvider.prototype.createRemoteStore = function (cfg) {
-        var _this = this;
-        return new RemoteStore(this.localStore, cfg.datastore, cfg.asyncQueue, function (onlineState) { return _this.syncEngine.applyOnlineStateChange(onlineState, 0 /* RemoteStore */); }, cfg.platform.newConnectivityMonitor());
-    };
-    MemoryComponentProvider.prototype.createSharedClientState = function (cfg) {
-        return new MemorySharedClientState();
-    };
-    MemoryComponentProvider.prototype.createSyncEngine = function (cfg) {
-        return new SyncEngine(this.localStore, this.remoteStore, this.sharedClientState, cfg.initialUser, cfg.maxConcurrentLimboResolutions);
-    };
-    MemoryComponentProvider.prototype.clearPersistence = function (databaseInfo) {
-        throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
+    IndexedDbComponentProvider.prototype.clearPersistence = function (databaseInfo) {
+        var persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
+        return IndexedDbPersistence.clearPersistence(persistenceKey);
     };
-    return MemoryComponentProvider;
+    return IndexedDbComponentProvider;
 }());
+var MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE = 'You are using the memory-only build of Firestore. Persistence support is ' +
+    'only available via the @firebase/firestore bundle or the ' +
+    'firebase-firestore.js build.';
 /**
- * Provides all components needed for Firestore with IndexedDB persistence.
+ * Provides all components needed for Firestore with in-memory persistence.
  */
-var IndexedDbComponentProvider = /** @class */ (function (_super) {
-    tslib.__extends(IndexedDbComponentProvider, _super);
-    function IndexedDbComponentProvider() {
-        return _super !== null && _super.apply(this, arguments) || this;
+var MemoryComponentProvider = /** @class */ (function () {
+    function MemoryComponentProvider(referenceDelegateFactory) {
+        if (referenceDelegateFactory === void 0) { referenceDelegateFactory = MemoryEagerDelegate.factory; }
+        this.referenceDelegateFactory = referenceDelegateFactory;
     }
-    IndexedDbComponentProvider.prototype.createGarbageCollectionScheduler = function (cfg) {
-        debugAssert(this.persistence instanceof IndexedDbPersistence, 'IndexedDbComponentProvider should provide IndexedDBPersistence');
-        var garbageCollector = this.persistence.referenceDelegate
-            .garbageCollector;
-        return new LruScheduler(garbageCollector, cfg.asyncQueue);
-    };
-    IndexedDbComponentProvider.prototype.createPersistence = function (cfg) {
-        debugAssert(cfg.persistenceSettings.durable, 'Can only start durable persistence');
-        var persistenceKey = IndexedDbPersistence.buildStoragePrefix(cfg.databaseInfo);
-        var serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
-        return IndexedDbPersistence.createIndexedDbPersistence({
-            allowTabSynchronization: cfg.persistenceSettings.synchronizeTabs,
-            persistenceKey: persistenceKey,
-            clientId: cfg.clientId,
-            platform: cfg.platform,
-            queue: cfg.asyncQueue,
-            serializer: serializer,
-            lruParams: LruParams.withCacheSize(cfg.persistenceSettings.cacheSizeBytes),
-            sequenceNumberSyncer: this.sharedClientState
-        });
-    };
-    IndexedDbComponentProvider.prototype.createSharedClientState = function (cfg) {
-        debugAssert(cfg.persistenceSettings.durable, 'Can only start durable persistence');
-        if (cfg.persistenceSettings.synchronizeTabs) {
-            if (!WebStorageSharedClientState.isAvailable(cfg.platform)) {
-                throw new FirestoreError(Code.UNIMPLEMENTED, 'IndexedDB persistence is only available on platforms that support LocalStorage.');
-            }
-            var persistenceKey = IndexedDbPersistence.buildStoragePrefix(cfg.databaseInfo);
-            return new WebStorageSharedClientState(cfg.asyncQueue, cfg.platform, persistenceKey, cfg.clientId, cfg.initialUser);
-        }
-        return new MemorySharedClientState();
+    MemoryComponentProvider.prototype.initialize = function (asyncQueue, databaseInfo, platform, datastore, clientId, initialUser, maxConcurrentLimboResolutions, persistenceSettings) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (persistenceSettings.durable) {
+                            throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
+                        }
+                        this.persistence = new MemoryPersistence(clientId, this.referenceDelegateFactory);
+                        this.gcScheduler = null;
+                        this.sharedClientState = new MemorySharedClientState();
+                        this.localStore = new LocalStore(this.persistence, new IndexFreeQueryEngine(), initialUser);
+                        this.remoteStore = new RemoteStore(this.localStore, datastore, asyncQueue, function (onlineState) { return _this.syncEngine.applyOnlineStateChange(onlineState, 0 /* RemoteStore */); }, platform.newConnectivityMonitor());
+                        this.syncEngine = new SyncEngine(this.localStore, this.remoteStore, this.sharedClientState, initialUser, maxConcurrentLimboResolutions);
+                        this.eventManager = new EventManager(this.syncEngine);
+                        this.remoteStore.syncEngine = this.syncEngine;
+                        return [4 /*yield*/, this.remoteStore.start()];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, this.remoteStore.applyPrimaryState(true)];
+                    case 2:
+                        _c.sent();
+                        return [4 /*yield*/, this.syncEngine.applyPrimaryState(true)];
+                    case 3:
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
-    IndexedDbComponentProvider.prototype.clearPersistence = function (databaseInfo) {
-        var persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
-        return IndexedDbPersistence.clearPersistence(persistenceKey);
+    MemoryComponentProvider.prototype.clearPersistence = function () {
+        throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
     };
-    return IndexedDbComponentProvider;
-}(MemoryComponentProvider));
+    return MemoryComponentProvider;
+}());
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -17118,16 +17120,7 @@ var FirestoreClient = /** @class */ (function () {
                         connection = _c.sent();
                         serializer = this.platform.newSerializer(this.databaseInfo.databaseId);
                         datastore = new Datastore(this.asyncQueue, connection, this.credentials, serializer);
-                        return [4 /*yield*/, componentProvider.initialize({
-                                asyncQueue: this.asyncQueue,
-                                databaseInfo: this.databaseInfo,
-                                platform: this.platform,
-                                datastore: datastore,
-                                clientId: this.clientId,
-                                initialUser: user,
-                                maxConcurrentLimboResolutions: MAX_CONCURRENT_LIMBO_RESOLUTIONS,
-                                persistenceSettings: persistenceSettings
-                            })];
+                        return [4 /*yield*/, componentProvider.initialize(this.asyncQueue, this.databaseInfo, this.platform, datastore, this.clientId, user, MAX_CONCURRENT_LIMBO_RESOLUTIONS, persistenceSettings)];
                     case 2:
                         _c.sent();
                         this.persistence = componentProvider.persistence;
@@ -22587,7 +22580,7 @@ var NodePlatform = /** @class */ (function () {
  */
 PlatformSupport.setPlatform(new NodePlatform());
 var name = "@firebase/firestore";
-var version = "1.14.0-canary.daf63c2c";
+var version = "1.14.0";
 /**
  * @license
  * Copyright 2017 Google LLC