@firebase/firestore 3.4.9-canary.f84cacd70 → 3.4.10

package/dist/internal.d.ts

@@ -984,7 +984,7 @@ declare interface DocumentOverlayCache {
      * Gets the saved overlay mutation for the given document keys. Skips keys for
      * which there are no overlays.
      */
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    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`.
@@ -2253,16 +2253,6 @@ declare interface FirstPartyCredentialsSettings {
  */
 declare type FulfilledHandler<T, R> = ((result: T) => R | PersistencePromise<R>) | null;
 
-/**
- * Interface implemented by the LRU scheduler to start(), stop() and restart
- * garbage collection.
- */
-declare interface GarbageCollectionScheduler {
-    readonly started: boolean;
-    start(localStore: LocalStore): void;
-    stop(): void;
-}
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -2560,6 +2550,8 @@ declare 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>;
 }
 
 /**
@@ -2834,8 +2826,119 @@ export declare interface LoadBundleTaskProgress {
     taskState: TaskState;
 }
 
+/**
+ * A readonly view of the local state of all documents we're tracking (i.e. we
+ * have a cached version in remoteDocumentCache or local mutations for the
+ * document). The view is computed by applying the mutations in the
+ * MutationQueue to the RemoteDocumentCache.
+ */
+declare class LocalDocumentsView {
+    readonly remoteDocumentCache: RemoteDocumentCache;
+    readonly mutationQueue: MutationQueue;
+    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`.
+     *
+     * @returns Local view of the document or null if we don't have any cached
+     * state for it.
+     */
+    getDocument(transaction: PersistenceTransaction, key: _DocumentKey): PersistencePromise<Document_2>;
+    /**
+     * Gets the local view of the documents identified by `keys`.
+     *
+     * If we don't have cached state for a document in `keys`, a NoDocument will
+     * be stored for that key in the resulting set.
+     */
+    getDocuments(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * 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.
+     */
+    recalculateAndSaveOverlaysForDocumentKeys(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<DocumentKeyMap<FieldMask | null>>;
+    /**
+     * Performs a query against the local view of all documents.
+     *
+     * @param transaction - The persistence transaction.
+     * @param query - The query to match documents against.
+     * @param offset - Read time and key to start scanning by (exclusive).
+     */
+    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query_2, 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;
+}
+
 declare 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;
+}
+
+/** The result of a write to the local store. */
+declare interface LocalWriteResult {
+    batchId: BatchId;
+    changes: DocumentMap;
 }
 export { LogLevel }
 
@@ -3061,7 +3164,7 @@ declare class MutationBatch {
      * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
      * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
+    applyToLocalDocumentSet(documentMap: OverlayedDocumentMap, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }
@@ -3085,7 +3188,7 @@ declare class MutationBatchResult {
     static from(batch: MutationBatch, commitVersion: SnapshotVersion, results: MutationResult[]): MutationBatchResult;
 }
 
-declare type MutationMap = ObjectMap<_DocumentKey, Mutation>;
+declare type MutationMap = DocumentKeyMap<Mutation>;
 
 /** A queue of mutations to apply to the remote store. */
 declare interface MutationQueue {
@@ -3391,7 +3494,8 @@ declare 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>;
@@ -3713,7 +3817,9 @@ declare class OverlayedDocument {
     mutatedFields: FieldMask | null);
 }
 
-declare type OverlayMap = ObjectMap<_DocumentKey, Overlay>;
+declare type OverlayedDocumentMap = DocumentKeyMap<OverlayedDocument>;
+
+declare type OverlayMap = DocumentKeyMap<Overlay>;
 
 declare interface ParseContext {
     readonly databaseId: _DatabaseId;
@@ -3932,6 +4038,17 @@ 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>;
 }
 
 /**
@@ -4565,6 +4682,15 @@ export declare class _ResourcePath extends BasePath<_ResourcePath> {
  */
 export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
 
+/**
+ * Interface to schedule periodic tasks within SDK.
+ */
+declare interface Scheduler {
+    readonly started: boolean;
+    start(): void;
+    stop(): void;
+}
+
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
  * include a server-generated timestamp in the written data.
@@ -5404,7 +5530,11 @@ declare const enum TimerId {
      * A timer used to retry operations scheduled via retryable AsyncQueue
      * operations.
      */
-    AsyncQueueRetry = "async_queue_retry"
+    AsyncQueueRetry = "async_queue_retry",
+    /**
+     *  A timer used to periodically attempt index backfill.
+     */
+    IndexBackfill = "index_backfill"
 }
 
 /**

package/dist/lite/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/lite/firestore/src/local/document_overlay_cache.d.ts

@@ -40,7 +40,7 @@ export interface DocumentOverlayCache {
      * Gets the saved overlay mutation for the given document keys. Skips keys for
      * which there are no overlays.
      */
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    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/lite/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/lite/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/lite/firestore/src/local/indexeddb_document_overlay_cache.d.ts

@@ -36,7 +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: DocumentKeySet): PersistencePromise<OverlayMap>;
+    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/lite/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/lite/firestore/src/local/local_documents_view.d.ts

@@ -15,15 +15,15 @@
  * limitations under the License.
  */
 import { Query } from '../core/query';
-import { DocumentKeySet, OverlayMap, DocumentMap, MutableDocumentMap, DocumentKeyMap } 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 { OverlayedDocument } from './overlayed_document';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -69,7 +69,7 @@ export declare class LocalDocumentsView {
      * 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<DocumentKeyMap<OverlayedDocument>>;
+    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.
@@ -87,7 +87,7 @@ export declare class LocalDocumentsView {
      *   overlays from mutation queues.
      * @return A map represents the local documents view.
      */
-    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<DocumentKeyMap<OverlayedDocument>>;
+    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<OverlayedDocumentMap>;
     private recalculateAndSaveOverlays;
     /**
      * Recalculates overlays by reading the documents from remote document cache
@@ -102,6 +102,22 @@ 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;

package/dist/lite/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/lite/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/lite/firestore/src/local/memory_document_overlay_cache.d.ts

@@ -28,7 +28,7 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    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/lite/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/lite/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/lite/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/lite/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,9 +33,12 @@ 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>;

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

@@ -17,8 +17,7 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { BatchId } from '../core/types';
 import { Timestamp } from '../lite-api/timestamp';
-import { OverlayedDocument } from '../local/overlayed_document';
-import { DocumentKeySet, MutationMap, DocumentVersionMap, DocumentKeyMap } from './collections';
+import { DocumentKeySet, MutationMap, DocumentVersionMap, OverlayedDocumentMap } from './collections';
 import { MutableDocument } from './document';
 import { FieldMask } from './field_mask';
 import { Mutation, MutationResult } from './mutation';
@@ -65,7 +64,7 @@ export declare class MutationBatch {
      * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
      * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
+    applyToLocalDocumentSet(documentMap: OverlayedDocumentMap, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }

package/dist/lite/firestore/src/util/async_queue.d.ts

@@ -59,7 +59,11 @@ export declare const enum TimerId {
      * A timer used to retry operations scheduled via retryable AsyncQueue
      * operations.
      */
-    AsyncQueueRetry = "async_queue_retry"
+    AsyncQueueRetry = "async_queue_retry",
+    /**
+     *  A timer used to periodically attempt index backfill.
+     */
+    IndexBackfill = "index_backfill"
 }
 /**
  * Represents an operation scheduled to be run in the future on an AsyncQueue.

package/dist/lite/firestore/test/unit/local/index_backfiller.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export {};

package/dist/lite/firestore/test/unit/local/test_document_overlay_cache.d.ts

@@ -31,7 +31,7 @@ export declare class TestDocumentOverlayCache {
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
     saveOverlays(largestBatch: number, data: MutationMap): Promise<void>;
     getOverlay(key: DocumentKey): Promise<Overlay | null>;
-    getOverlays(keys: DocumentKeySet): Promise<OverlayMap>;
+    getOverlays(keys: DocumentKey[]): Promise<OverlayMap>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
     getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
     getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;