@firebase/firestore 3.4.9 → 3.4.10-canary.ebc17e27f

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @firebase/firestore
 
+## 3.4.10
+
+### Patch Changes
+
+- [`2cd1cc76f`](https://github.com/firebase/firebase-js-sdk/commit/2cd1cc76f2a308135cd60f424fe09084a34b5cb5) [#6307](https://github.com/firebase/firebase-js-sdk/pull/6307) (fixes [#6300](https://github.com/firebase/firebase-js-sdk/issues/6300)) - fix: add type declarations to exports field
+
+* [`d4b52b612`](https://github.com/firebase/firebase-js-sdk/commit/d4b52b612cf73610c57a3c08a0415ab7b622a70a) [#6321](https://github.com/firebase/firebase-js-sdk/pull/6321) - Fix incorrect paths in package.json
+
+* Updated dependencies [[`2cd1cc76f`](https://github.com/firebase/firebase-js-sdk/commit/2cd1cc76f2a308135cd60f424fe09084a34b5cb5)]:
+  - @firebase/component@0.5.15
+  - @firebase/logger@0.3.3
+  - @firebase/util@1.6.1
+  - @firebase/webchannel-wrapper@0.6.2
+
 ## 3.4.9
 
 ### Patch Changes

package/dist/firestore/src/api/transaction.d.ts

@@ -51,6 +51,8 @@ export declare class Transaction extends LiteTransaction {
  * transaction against.
  * @param updateFunction - The function to execute within the transaction
  * context.
+ * @param options - An options object to configure maximum number of attempts to
+ * commit.
  * @returns If the transaction completed successfully or was explicitly aborted
  * (the `updateFunction` returned a failed promise), the promise returned by the
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a

package/dist/firestore/src/core/component_provider.d.ts

@@ -18,7 +18,7 @@ import { CredentialsProvider } from '../api/credentials';
 import { User } from '../auth/user';
 import { IndexedDbPersistence } from '../local/indexeddb_persistence';
 import { LocalStore } from '../local/local_store';
-import { GarbageCollectionScheduler, Persistence } from '../local/persistence';
+import { Scheduler, Persistence } from '../local/persistence';
 import { ClientId, SharedClientState } from '../local/shared_client_state';
 import { Datastore } from '../remote/datastore';
 import { RemoteStore } from '../remote/remote_store';
@@ -44,7 +44,8 @@ export interface OfflineComponentProvider {
     persistence: Persistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     initialize(cfg: ComponentConfiguration): Promise<void>;
     terminate(): Promise<void>;
@@ -57,11 +58,13 @@ export declare class MemoryOfflineComponentProvider implements OfflineComponentP
     persistence: Persistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     serializer: JsonProtoSerializer;
     initialize(cfg: ComponentConfiguration): Promise<void>;
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
+    createIndexBackfillerScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
     createLocalStore(cfg: ComponentConfiguration): LocalStore;
     createPersistence(cfg: ComponentConfiguration): Persistence;
     createSharedClientState(cfg: ComponentConfiguration): SharedClientState;
@@ -77,12 +80,14 @@ export declare class IndexedDbOfflineComponentProvider extends MemoryOfflineComp
     persistence: IndexedDbPersistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     constructor(onlineComponentProvider: OnlineComponentProvider, cacheSizeBytes: number | undefined, forceOwnership: boolean | undefined);
     initialize(cfg: ComponentConfiguration): Promise<void>;
     createLocalStore(cfg: ComponentConfiguration): LocalStore;
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
+    createIndexBackfillerScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
     createPersistence(cfg: ComponentConfiguration): IndexedDbPersistence;
     createSharedClientState(cfg: ComponentConfiguration): SharedClientState;
 }

package/dist/firestore/src/lite-api/transaction.d.ts

@@ -112,6 +112,8 @@ export declare class Transaction {
  * transaction against.
  * @param updateFunction - The function to execute within the transaction
  * context.
+ * @param options - An options object to configure maximum number of attempts to
+ * commit.
  * @returns If the transaction completed successfully or was explicitly aborted
  * (the `updateFunction` returned a failed promise), the promise returned by the
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a

package/dist/firestore/src/local/document_overlay_cache.d.ts

@@ -36,6 +36,11 @@ export interface DocumentOverlayCache {
      * Returns null if there is no overlay for that key.
      */
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * Gets the saved overlay mutation for the given document keys. Skips keys for
+     * which there are no overlays.
+     */
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     /**
      * Saves the given document mutation map to persistence as overlays.
      * All overlays will have their largest batch id set to `largestBatchId`.

package/dist/firestore/src/local/index_backfiller.d.ts

@@ -0,0 +1,44 @@
+import { AsyncQueue } from '../util/async_queue';
+import { LocalStore } from './local_store';
+import { Persistence, Scheduler } from './persistence';
+/** This class is responsible for the scheduling of Index Backfiller. */
+export declare class IndexBackfillerScheduler implements Scheduler {
+    private readonly asyncQueue;
+    private readonly backfiller;
+    private task;
+    constructor(asyncQueue: AsyncQueue, backfiller: IndexBackfiller);
+    start(): void;
+    stop(): void;
+    get started(): boolean;
+    private schedule;
+}
+/** Implements the steps for backfilling indexes. */
+export declare class IndexBackfiller {
+    /**
+     * LocalStore provides access to IndexManager and LocalDocumentView.
+     * These properties will update when the user changes. Consequently,
+     * making a local copy of IndexManager and LocalDocumentView will require
+     * updates over time. The simpler solution is to rely on LocalStore to have
+     * an up-to-date references to IndexManager and LocalDocumentStore.
+     */
+    private readonly localStore;
+    private readonly persistence;
+    constructor(
+    /**
+     * LocalStore provides access to IndexManager and LocalDocumentView.
+     * These properties will update when the user changes. Consequently,
+     * making a local copy of IndexManager and LocalDocumentView will require
+     * updates over time. The simpler solution is to rely on LocalStore to have
+     * an up-to-date references to IndexManager and LocalDocumentStore.
+     */
+    localStore: LocalStore, persistence: Persistence);
+    backfill(maxDocumentsToProcess?: number): Promise<number>;
+    /** Writes index entries until the cap is reached. Returns the number of documents processed. */
+    private writeIndexEntries;
+    /**
+     * Writes entries for the provided collection group. Returns the number of documents processed.
+     */
+    private writeEntriesForCollectionGroup;
+    /** Returns the next offset based on the provided documents. */
+    private getNewOffset;
+}

package/dist/firestore/src/local/index_manager.d.ts

@@ -114,4 +114,6 @@ export interface IndexManager {
      * and returns the minimum offset of them all.
      */
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
+    /** Returns the minimum offset for the given collection group. */
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
 }

package/dist/firestore/src/local/indexeddb_document_overlay_cache.d.ts

@@ -36,6 +36,7 @@ export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCac
     constructor(serializer: LocalSerializer, userId: string);
     static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: MutationMap): PersistencePromise<void>;
     removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
     getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;

package/dist/firestore/src/local/indexeddb_index_manager.d.ts

@@ -128,5 +128,6 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     private createRange;
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

package/dist/firestore/src/local/indexeddb_schema.d.ts

@@ -21,7 +21,7 @@ import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, Que
 import { EncodedResourcePath } from './encoded_resource_path';
 import { DbTimestampKey } from './indexeddb_sentinels';
 export declare const INDEXING_ENABLED = false;
-export declare const INDEXING_SCHEMA_VERSION = 14;
+export declare const INDEXING_SCHEMA_VERSION = 15;
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -43,7 +43,8 @@ export declare const INDEXING_SCHEMA_VERSION = 14;
  * 12. Add document overlays.
  * 13. Rewrite the keys of the remote document cache to allow for efficient
  *     document lookup via `getAll()`.
- * 14. Add indexing support.
+ * 14. Add overlays.
+ * 15. Add indexing support.
  */
 export declare const SCHEMA_VERSION: number;
 /**

package/dist/firestore/src/local/indexeddb_schema_converter.d.ts

@@ -39,4 +39,5 @@ export declare class SchemaConverter implements SimpleDbSchemaConverter {
     private createCollectionParentIndex;
     private rewriteCanonicalIds;
     private rewriteRemoteDocumentCache;
+    private runOverlayMigration;
 }

package/dist/firestore/src/local/indexeddb_sentinels.d.ts

@@ -240,6 +240,7 @@ export declare const V11_STORES: string[];
 export declare const V12_STORES: string[];
 export declare const V13_STORES: string[];
 export declare const V14_STORES: string[];
+export declare const V15_STORES: string[];
 /**
  * The list of all default IndexedDB stores used throughout the SDK. This is
  * used when creating transactions so that access across all stores is done

package/dist/firestore/src/local/local_documents_view.d.ts

@@ -15,11 +15,14 @@
  * limitations under the License.
  */
 import { Query } from '../core/query';
-import { DocumentKeySet, DocumentMap, MutableDocumentMap } from '../model/collections';
+import { DocumentKeySet, OverlayMap, DocumentMap, MutableDocumentMap, DocumentKeyMap, OverlayedDocumentMap } from '../model/collections';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { IndexOffset } from '../model/field_index';
+import { FieldMask } from '../model/field_mask';
+import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
+import { LocalWriteResult } from './local_store_impl';
 import { MutationQueue } from './mutation_queue';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
@@ -33,8 +36,9 @@ import { RemoteDocumentCache } from './remote_document_cache';
 export declare class LocalDocumentsView {
     readonly remoteDocumentCache: RemoteDocumentCache;
     readonly mutationQueue: MutationQueue;
-    private readonly indexManager;
-    constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, indexManager: IndexManager);
+    readonly documentOverlayCache: DocumentOverlayCache;
+    readonly indexManager: IndexManager;
+    constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, documentOverlayCache: DocumentOverlayCache, indexManager: IndexManager);
     /**
      * Get the local view of the document identified by `key`.
      *
@@ -42,9 +46,6 @@ export declare class LocalDocumentsView {
      * state for it.
      */
     getDocument(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Document>;
-    /** Internal version of `getDocument` that allows reusing batches. */
-    private getDocumentInternal;
-    private applyLocalMutationsToDocuments;
     /**
      * Gets the local view of the documents identified by `keys`.
      *
@@ -53,10 +54,46 @@ export declare class LocalDocumentsView {
      */
     getDocuments(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<DocumentMap>;
     /**
-     * Applies the local view the given `baseDocs` without retrieving documents
-     * from the local store.
+     * Similar to `getDocuments`, but creates the local view from the given
+     * `baseDocs` without retrieving documents from the local store.
+     *
+     * @param transaction - The transaction this operation is scoped to.
+     * @param docs - The documents to apply local mutations to get the local views.
+     * @param existenceStateChanged - The set of document keys whose existence state
+     *   is changed. This is useful to determine if some documents overlay needs
+     *   to be recalculated.
+     */
+    getLocalViewOfDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap, existenceStateChanged?: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * Gets the overlayed documents for the given document map, which will include
+     * the local view of those documents and a `FieldMask` indicating which fields
+     * are mutated locally, `null` if overlay is a Set or Delete mutation.
+     */
+    getOverlayedDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap): PersistencePromise<OverlayedDocumentMap>;
+    /**
+     * Fetches the overlays for {@code docs} and adds them to provided overlay map
+     * if the map does not already contain an entry for the given document key.
+     */
+    private populateOverlays;
+    /**
+     * Computes the local view for the given documents.
+     *
+     * @param docs - The documents to compute views for. It also has the base
+     *   version of the documents.
+     * @param overlays - The overlays that need to be applied to the given base
+     *   version of the documents.
+     * @param existenceStateChanged - A set of documents whose existence states
+     *   might have changed. This is used to determine if we need to re-calculate
+     *   overlays from mutation queues.
+     * @return A map represents the local documents view.
+     */
+    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<OverlayedDocumentMap>;
+    private recalculateAndSaveOverlays;
+    /**
+     * Recalculates overlays by reading the documents from remote document cache
+     * first, and saves them after they are calculated.
      */
-    applyLocalViewToDocuments(transaction: PersistenceTransaction, baseDocs: MutableDocumentMap): PersistencePromise<void>;
+    recalculateAndSaveOverlaysForDocumentKeys(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<DocumentKeyMap<FieldMask | null>>;
     /**
      * Performs a query against the local view of all documents.
      *
@@ -65,7 +102,25 @@ export declare class LocalDocumentsView {
      * @param offset - Read time and key to start scanning by (exclusive).
      */
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, offset: IndexOffset): PersistencePromise<DocumentMap>;
+    /**
+     * Given a collection group, returns the next documents that follow the provided offset, along
+     * with an updated batch ID.
+     *
+     * <p>The documents returned by this method are ordered by remote version from the provided
+     * offset. If there are no more remote documents after the provided offset, documents with
+     * mutations in order of batch id from the offset are returned. Since all documents in a batch are
+     * returned together, the total number of documents returned can exceed {@code count}.
+     *
+     * @param transaction
+     * @param collectionGroup The collection group for the documents.
+     * @param offset The offset to index into.
+     * @param count The number of documents to return
+     * @return A LocalWriteResult with the documents that follow the provided offset and the last processed batch id.
+     */
+    getNextDocuments(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset, count: number): PersistencePromise<LocalWriteResult>;
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
+    /** Returns a base document that can be used to apply `overlay`. */
+    private getBaseDocument;
 }

package/dist/firestore/src/local/local_store.d.ts

@@ -15,9 +15,18 @@
  * limitations under the License.
  */
 import { FirestoreError } from '../util/error';
+import { IndexManager } from './index_manager';
+import { LocalDocumentsView } from './local_documents_view';
 import { LruGarbageCollector, LruResults } from './lru_garbage_collector';
 export interface LocalStore {
     collectGarbage(garbageCollector: LruGarbageCollector): Promise<LruResults>;
+    /** Manages the list of active field and collection indices. */
+    indexManager: IndexManager;
+    /**
+     * The "local" view of all documents (layering mutationQueue on top of
+     * remoteDocumentCache).
+     */
+    localDocuments: LocalDocumentsView;
 }
 /**
  * Verifies the error thrown by a LocalStore operation. If a LocalStore

package/dist/firestore/src/local/lru_garbage_collector_impl.d.ts

@@ -17,19 +17,19 @@
 import { AsyncQueue } from '../util/async_queue';
 import { LocalStore } from './local_store';
 import { LruDelegate, LruGarbageCollector, LruParams } from './lru_garbage_collector';
-import { GarbageCollectionScheduler } from './persistence';
+import { Scheduler } from './persistence';
 export declare const LRU_MINIMUM_CACHE_SIZE_BYTES: number;
 /**
  * This class is responsible for the scheduling of LRU garbage collection. It handles checking
  * whether or not GC is enabled, as well as which delay to use before the next run.
  */
-export declare class LruScheduler implements GarbageCollectionScheduler {
+export declare class LruScheduler implements Scheduler {
     private readonly garbageCollector;
     private readonly asyncQueue;
-    private hasRun;
+    private readonly localStore;
     private gcTask;
-    constructor(garbageCollector: LruGarbageCollector, asyncQueue: AsyncQueue);
-    start(localStore: LocalStore): void;
+    constructor(garbageCollector: LruGarbageCollector, asyncQueue: AsyncQueue, localStore: LocalStore);
+    start(): void;
     stop(): void;
     get started(): boolean;
     private scheduleGC;

package/dist/firestore/src/local/memory_document_overlay_cache.d.ts

@@ -28,6 +28,7 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: MutationMap): PersistencePromise<void>;
     removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
     getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;

package/dist/firestore/src/local/memory_index_manager.d.ts

@@ -36,6 +36,7 @@ export declare class MemoryIndexManager implements IndexManager {
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

package/dist/firestore/src/local/overlayed_document.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+import { Document } from '../model/document';
+import { FieldMask } from '../model/field_mask';
+/**
+ * Represents a local view (overlay) of a document, and the fields that are
+ * locally mutated.
+ */
+export declare class OverlayedDocument {
+    readonly overlayedDocument: Document;
+    /**
+     * The fields that are locally mutated by patch mutations. If the overlayed
+     * document is from set or delete mutations, this returns null.
+     */
+    readonly mutatedFields: FieldMask | null;
+    constructor(overlayedDocument: Document, 
+    /**
+     * The fields that are locally mutated by patch mutations. If the overlayed
+     * document is from set or delete mutations, this returns null.
+     */
+    mutatedFields: FieldMask | null);
+}

package/dist/firestore/src/local/persistence.d.ts

@@ -20,7 +20,6 @@ import { DocumentKey } from '../model/document_key';
 import { BundleCache } from './bundle_cache';
 import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
-import { LocalStore } from './local_store';
 import { MutationQueue } from './mutation_queue';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction, PersistenceTransactionMode } from './persistence_transaction';
@@ -204,11 +203,10 @@ export interface Persistence {
     runTransaction<T>(action: string, mode: PersistenceTransactionMode, transactionOperation: (transaction: PersistenceTransaction) => PersistencePromise<T>): Promise<T>;
 }
 /**
- * Interface implemented by the LRU scheduler to start(), stop() and restart
- * garbage collection.
+ * Interface to schedule periodic tasks within SDK.
  */
-export interface GarbageCollectionScheduler {
+export interface Scheduler {
     readonly started: boolean;
-    start(localStore: LocalStore): void;
+    start(): void;
     stop(): void;
 }

package/dist/firestore/src/local/persistence_promise.d.ts

@@ -69,4 +69,15 @@ export declare class PersistencePromise<T> {
     static forEach<R>(collection: {
         forEach: (cb: (r: R) => void) => void;
     }, f: (r: R) => PersistencePromise<void>): PersistencePromise<void>;
+    /**
+     * Concurrently map all array elements through asynchronous function.
+     */
+    static mapArray<T, U>(array: T[], f: (t: T) => PersistencePromise<U>): PersistencePromise<U[]>;
+    /**
+     * An alternative to recursive PersistencePromise calls, that avoids
+     * potential memory problems from unbounded chains of promises.
+     *
+     * The `action` will be called repeatedly while `condition` is true.
+     */
+    static doWhile(condition: () => boolean, action: () => PersistencePromise<void>): PersistencePromise<void>;
 }

package/dist/firestore/src/local/query_engine.d.ts

@@ -83,7 +83,7 @@ export declare class QueryEngine {
      * Determines if a limit query needs to be refilled from cache, making it
      * ineligible for index-free execution.
      *
-     * @param query The query.
+     * @param query - The query.
      * @param sortedPreviousResults - The documents that matched the query when it
      * was last synchronized, sorted by the query's comparator.
      * @param remoteKeys - The document keys that matched the query at the last

package/dist/firestore/src/model/collections.d.ts

@@ -16,6 +16,7 @@
  */
 import { SnapshotVersion } from '../core/snapshot_version';
 import { TargetId } from '../core/types';
+import { OverlayedDocument } from '../local/overlayed_document';
 import { ObjectMap } from '../util/obj_map';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
@@ -32,10 +33,15 @@ export interface DocumentSizeEntries {
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
 export declare function documentMap(...docs: Document[]): DocumentMap;
-export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
+export declare type OverlayedDocumentMap = DocumentKeyMap<OverlayedDocument>;
+export declare function newOverlayedDocumentMap(): OverlayedDocumentMap;
+export declare function convertOverlayedDocumentMapToDocumentMap(collection: OverlayedDocumentMap): DocumentMap;
+export declare type OverlayMap = DocumentKeyMap<Overlay>;
 export declare function newOverlayMap(): OverlayMap;
-export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;
+export declare type MutationMap = DocumentKeyMap<Mutation>;
 export declare function newMutationMap(): MutationMap;
+export declare type DocumentKeyMap<T> = ObjectMap<DocumentKey, T>;
+export declare function newDocumentKeyMap<T>(): DocumentKeyMap<T>;
 export declare type DocumentVersionMap = SortedMap<DocumentKey, SnapshotVersion>;
 export declare function documentVersionMap(): DocumentVersionMap;
 export declare type DocumentKeySet = SortedSet<DocumentKey>;

package/dist/firestore/src/model/field_mask.d.ts

@@ -28,6 +28,12 @@ import { FieldPath } from './path';
 export declare class FieldMask {
     readonly fields: FieldPath[];
     constructor(fields: FieldPath[]);
+    static empty(): FieldMask;
+    /**
+     * Returns a new FieldMask object that is the result of adding all the given
+     * fields paths to this field mask.
+     */
+    unionWith(extraFields: FieldPath[]): FieldMask;
     /**
      * Verifies that `fieldPath` is included by at least one field in this field
      * mask.

package/dist/firestore/src/model/mutation.d.ts

@@ -149,7 +149,19 @@ export declare abstract class Mutation {
     abstract readonly key: DocumentKey;
     abstract readonly precondition: Precondition;
     abstract readonly fieldTransforms: FieldTransform[];
+    /**
+     * Returns a `FieldMask` representing the fields that will be changed by
+     * applying this mutation. Returns `null` if the mutation will overwrite the
+     * entire document.
+     */
+    abstract getFieldMask(): FieldMask | null;
 }
+/**
+ * A utility method to calculate a `Mutation` representing the overlay from the
+ * final state of the document, and a `FieldMask` representing the fields that
+ * are mutated by the local mutations.
+ */
+export declare function calculateOverlayMutation(doc: MutableDocument, mask: FieldMask | null): Mutation | null;
 /**
  * Applies this mutation to the given document for the purposes of computing a
  * new remote document. If the input document doesn't match the expected state
@@ -172,10 +184,12 @@ export declare function mutationApplyToRemoteDocument(mutation: Mutation, docume
  * @param document - The document to mutate. The input document can be an
  *     invalid document if the client has no knowledge of the pre-mutation state
  *     of the document.
+ * @param previousMask - The fields that have been updated before applying this mutation.
  * @param localWriteTime - A timestamp indicating the local write time of the
  *     batch this mutation is a part of.
+ * @returns A `FieldMask` representing the fields that are changed by applying this mutation.
  */
-export declare function mutationApplyToLocalView(mutation: Mutation, document: MutableDocument, localWriteTime: Timestamp): void;
+export declare function mutationApplyToLocalView(mutation: Mutation, document: MutableDocument, previousMask: FieldMask | null, localWriteTime: Timestamp): FieldMask | null;
 /**
  * If this mutation is not idempotent, returns the base value to persist with
  * this mutation. If a base value is returned, the mutation is always applied
@@ -205,6 +219,7 @@ export declare class SetMutation extends Mutation {
     readonly fieldTransforms: FieldTransform[];
     constructor(key: DocumentKey, value: ObjectValue, precondition: Precondition, fieldTransforms?: FieldTransform[]);
     readonly type: MutationType;
+    getFieldMask(): FieldMask | null;
 }
 /**
  * A mutation that modifies fields of the document at the given key with the
@@ -227,6 +242,7 @@ export declare class PatchMutation extends Mutation {
     readonly fieldTransforms: FieldTransform[];
     constructor(key: DocumentKey, data: ObjectValue, fieldMask: FieldMask, precondition: Precondition, fieldTransforms?: FieldTransform[]);
     readonly type: MutationType;
+    getFieldMask(): FieldMask | null;
 }
 /** A mutation that deletes the document at the given key. */
 export declare class DeleteMutation extends Mutation {
@@ -235,6 +251,7 @@ export declare class DeleteMutation extends Mutation {
     constructor(key: DocumentKey, precondition: Precondition);
     readonly type: MutationType;
     readonly fieldTransforms: FieldTransform[];
+    getFieldMask(): FieldMask | null;
 }
 /**
  * A mutation that verifies the existence of the document at the given key with
@@ -249,4 +266,5 @@ export declare class VerifyMutation extends Mutation {
     constructor(key: DocumentKey, precondition: Precondition);
     readonly type: MutationType;
     readonly fieldTransforms: FieldTransform[];
+    getFieldMask(): FieldMask | null;
 }

package/dist/firestore/src/model/mutation_batch.d.ts

@@ -17,8 +17,9 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { BatchId } from '../core/types';
 import { Timestamp } from '../lite-api/timestamp';
-import { DocumentKeySet, DocumentMap, DocumentVersionMap } from './collections';
+import { DocumentKeySet, MutationMap, DocumentVersionMap, OverlayedDocumentMap } from './collections';
 import { MutableDocument } from './document';
+import { FieldMask } from './field_mask';
 import { Mutation, MutationResult } from './mutation';
 /**
  * A batch of mutations that will be sent as one unit to the backend.
@@ -54,13 +55,16 @@ export declare class MutationBatch {
      * batch.
      *
      * @param document - The document to apply mutations to.
+     * @param mutatedFields - Fields that have been updated before applying this mutation batch.
+     * @returns A `FieldMask` representing all the fields that are mutated.
      */
-    applyToLocalView(document: MutableDocument): void;
+    applyToLocalView(document: MutableDocument, mutatedFields: FieldMask | null): FieldMask | null;
     /**
      * Computes the local view for all provided documents given the mutations in
-     * this batch.
+     * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
+     * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentMap): void;
+    applyToLocalDocumentSet(documentMap: OverlayedDocumentMap, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }

package/dist/firestore/src/tsdoc-metadata.json

@@ -1,11 +1,11 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "0.1.2"
-    }
-  ]
-}
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "0.1.2"
+    }
+  ]
+}