@firebase/firestore 1.14.0-canary.daf63c2c → 1.14.0

package/dist/index.memory.node.esm2017.js

@@ -10424,9 +10424,6 @@ class MemoryPersistence {
         this.indexManager = new MemoryIndexManager();
         this.remoteDocumentCache = new MemoryRemoteDocumentCache(this.indexManager, sizer);
     }
-    start() {
-        return Promise.resolve();
-    }
     shutdown() {
         // No durable state to ensure is closed on shutdown.
         this._started = false;
@@ -10598,61 +10595,28 @@ const MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE = 'You are using the memory-only bui
     'firebase-firestore.js build.';
 /**
  * Provides all components needed for Firestore with in-memory persistence.
- * Uses EagerGC garbage collection.
  */
 class MemoryComponentProvider {
-    async initialize(cfg) {
-        this.sharedClientState = this.createSharedClientState(cfg);
-        this.persistence = this.createPersistence(cfg);
-        await this.persistence.start();
-        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);
-        this.sharedClientState.onlineStateHandler = onlineState => this.syncEngine.applyOnlineStateChange(onlineState, 1 /* SharedClientState */);
+    constructor(referenceDelegateFactory = MemoryEagerDelegate.factory) {
+        this.referenceDelegateFactory = referenceDelegateFactory;
+    }
+    async initialize(asyncQueue, databaseInfo, platform, datastore, clientId, initialUser, maxConcurrentLimboResolutions, persistenceSettings) {
+        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, onlineState => 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;
-        await this.sharedClientState.start();
         await this.remoteStore.start();
-        await this.localStore.start();
-        // NOTE: This will immediately call the listener, so we make sure to
-        // set it after localStore / remoteStore are started.
-        await this.persistence.setPrimaryStateListener(async (isPrimary) => {
-            await this.syncEngine.applyPrimaryState(isPrimary);
-            if (this.gcScheduler) {
-                if (isPrimary && !this.gcScheduler.started) {
-                    this.gcScheduler.start(this.localStore);
-                }
-                else if (!isPrimary) {
-                    this.gcScheduler.stop();
-                }
-            }
-        });
-    }
-    createEventManager(cfg) {
-        return new EventManager(this.syncEngine);
+        await this.remoteStore.applyPrimaryState(true);
+        await this.syncEngine.applyPrimaryState(true);
     }
-    createGarbageCollectionScheduler(cfg) {
-        return null;
-    }
-    createLocalStore(cfg) {
-        return new LocalStore(this.persistence, new IndexFreeQueryEngine(), cfg.initialUser);
-    }
-    createPersistence(cfg) {
-        debugAssert(!cfg.persistenceSettings.durable, 'Can only start memory persistence');
-        return new MemoryPersistence(cfg.clientId, MemoryEagerDelegate.factory);
-    }
-    createRemoteStore(cfg) {
-        return new RemoteStore(this.localStore, cfg.datastore, cfg.asyncQueue, onlineState => this.syncEngine.applyOnlineStateChange(onlineState, 0 /* RemoteStore */), cfg.platform.newConnectivityMonitor());
-    }
-    createSharedClientState(cfg) {
-        return new MemorySharedClientState();
-    }
-    createSyncEngine(cfg) {
-        return new SyncEngine(this.localStore, this.remoteStore, this.sharedClientState, cfg.initialUser, cfg.maxConcurrentLimboResolutions);
-    }
-    clearPersistence(databaseInfo) {
+    clearPersistence() {
         throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
     }
 }
@@ -11357,16 +11321,7 @@ class FirestoreClient {
             const connection = await this.platform.loadConnection(this.databaseInfo);
             const serializer = this.platform.newSerializer(this.databaseInfo.databaseId);
             const datastore = new Datastore(this.asyncQueue, connection, this.credentials, serializer);
-            await componentProvider.initialize({
-                asyncQueue: this.asyncQueue,
-                databaseInfo: this.databaseInfo,
-                platform: this.platform,
-                datastore,
-                clientId: this.clientId,
-                initialUser: user,
-                maxConcurrentLimboResolutions: MAX_CONCURRENT_LIMBO_RESOLUTIONS,
-                persistenceSettings
-            });
+            await componentProvider.initialize(this.asyncQueue, this.databaseInfo, this.platform, datastore, this.clientId, user, MAX_CONCURRENT_LIMBO_RESOLUTIONS, persistenceSettings);
             this.persistence = componentProvider.persistence;
             this.sharedClientState = componentProvider.sharedClientState;
             this.localStore = componentProvider.localStore;
@@ -16514,7 +16469,7 @@ class NodePlatform {
 PlatformSupport.setPlatform(new NodePlatform());
 
 var name = "@firebase/firestore";
-var version = "1.14.0-canary.daf63c2c";
+var version = "1.14.0";
 
 /**
  * @license