@firebase/firestore 1.14.0-canary.daf63c2c → 1.14.0

package/dist/index.node.esm2017.js

@@ -13683,11 +13683,12 @@ class IndexedDbPersistence {
             throw fail('IndexedDbPersistence must use instances of IndexedDbTransaction');
         }
     }
-    static createIndexedDbPersistence(options) {
+    static async createIndexedDbPersistence(options) {
         if (!IndexedDbPersistence.isAvailable()) {
             throw new FirestoreError(Code.UNIMPLEMENTED, UNSUPPORTED_PLATFORM_ERROR_MSG);
         }
         const persistence = new IndexedDbPersistence(options.allowTabSynchronization, options.persistenceKey, options.clientId, options.platform, options.lruParams, options.queue, options.serializer, options.sequenceNumberSyncer);
+        await persistence.start();
         return persistence;
     }
     /**
@@ -14958,9 +14959,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;
@@ -15127,24 +15125,39 @@ class MemoryEagerDelegate {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const 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.
  */
-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);
+class IndexedDbComponentProvider {
+    async initialize(asyncQueue, databaseInfo, platform, datastore, clientId, initialUser, maxConcurrentLimboResolutions, persistenceSettings) {
+        debugAssert(persistenceSettings.durable, 'IndexedDbComponentProvider can only provide durable persistence');
+        debugAssert(!this.sharedClientState, 'initialize() already called');
+        const persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
+        const 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 = onlineState => this.syncEngine.applyOnlineStateChange(onlineState, 1 /* SharedClientState */);
+        this.persistence = await IndexedDbPersistence.createIndexedDbPersistence({
+            allowTabSynchronization: persistenceSettings.synchronizeTabs,
+            persistenceKey,
+            clientId,
+            platform,
+            queue: asyncQueue,
+            serializer,
+            lruParams: LruParams.withCacheSize(persistenceSettings.cacheSizeBytes),
+            sequenceNumberSyncer: this.sharedClientState
+        });
+        const 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, 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();
@@ -15154,81 +15167,47 @@ class MemoryComponentProvider {
         // 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();
-                }
+            if (isPrimary && !this.gcScheduler.started) {
+                this.gcScheduler.start(this.localStore);
+            }
+            else if (!isPrimary) {
+                this.gcScheduler.stop();
             }
         });
     }
-    createEventManager(cfg) {
-        return new EventManager(this.syncEngine);
-    }
-    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) {
-        throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
+        const persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
+        return IndexedDbPersistence.clearPersistence(persistenceKey);
     }
 }
+const 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.
  */
-class IndexedDbComponentProvider extends MemoryComponentProvider {
-    createGarbageCollectionScheduler(cfg) {
-        debugAssert(this.persistence instanceof IndexedDbPersistence, 'IndexedDbComponentProvider should provide IndexedDBPersistence');
-        const garbageCollector = this.persistence.referenceDelegate
-            .garbageCollector;
-        return new LruScheduler(garbageCollector, cfg.asyncQueue);
-    }
-    createPersistence(cfg) {
-        debugAssert(cfg.persistenceSettings.durable, 'Can only start durable persistence');
-        const persistenceKey = IndexedDbPersistence.buildStoragePrefix(cfg.databaseInfo);
-        const serializer = cfg.platform.newSerializer(cfg.databaseInfo.databaseId);
-        return IndexedDbPersistence.createIndexedDbPersistence({
-            allowTabSynchronization: cfg.persistenceSettings.synchronizeTabs,
-            persistenceKey,
-            clientId: cfg.clientId,
-            platform: cfg.platform,
-            queue: cfg.asyncQueue,
-            serializer,
-            lruParams: LruParams.withCacheSize(cfg.persistenceSettings.cacheSizeBytes),
-            sequenceNumberSyncer: this.sharedClientState
-        });
-    }
-    createSharedClientState(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.');
-            }
-            const persistenceKey = IndexedDbPersistence.buildStoragePrefix(cfg.databaseInfo);
-            return new WebStorageSharedClientState(cfg.asyncQueue, cfg.platform, persistenceKey, cfg.clientId, cfg.initialUser);
-        }
-        return new MemorySharedClientState();
+class MemoryComponentProvider {
+    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;
+        await this.remoteStore.start();
+        await this.remoteStore.applyPrimaryState(true);
+        await this.syncEngine.applyPrimaryState(true);
     }
-    clearPersistence(databaseInfo) {
-        const persistenceKey = IndexedDbPersistence.buildStoragePrefix(databaseInfo);
-        return IndexedDbPersistence.clearPersistence(persistenceKey);
+    clearPersistence() {
+        throw new FirestoreError(Code.FAILED_PRECONDITION, MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE);
     }
 }
 
@@ -15932,16 +15911,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;
@@ -21089,7 +21059,7 @@ class NodePlatform {
 PlatformSupport.setPlatform(new NodePlatform());
 
 var name = "@firebase/firestore";
-var version = "1.14.0-canary.daf63c2c";
+var version = "1.14.0";
 
 /**
  * @license