@firebase/firestore 3.4.8 → 3.4.9-canary.0197076b8

package/dist/lite/packages/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/lite/packages/firestore/src/model/mutation_batch.d.ts

@@ -17,8 +17,10 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { BatchId } from '../core/types';
 import { Timestamp } from '../lite-api/timestamp';
-import { DocumentKeySet, DocumentMap, DocumentVersionMap } from './collections';
+import { OverlayedDocument } from '../local/overlayed_document';
+import { DocumentKeySet, MutationMap, DocumentVersionMap, DocumentKeyMap } 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 +56,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: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }

package/dist/lite/packages/firestore/src/model/values.d.ts

@@ -81,5 +81,17 @@ export declare function isMaxValue(value: Value): boolean;
 export declare function valuesGetLowerBound(value: Value): Value;
 /** Returns the largest value for the given value type (exclusive). */
 export declare function valuesGetUpperBound(value: Value): Value;
-export declare function valuesMax(left: Value | undefined, right: Value | undefined): Value | undefined;
-export declare function valuesMin(left: Value | undefined, right: Value | undefined): Value | undefined;
+export declare function lowerBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;
+export declare function upperBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;

package/dist/lite/packages/firestore/src/util/misc.d.ts

@@ -25,6 +25,9 @@ export declare function primitiveComparator<T>(left: T, right: T): number;
 export interface Equatable<T> {
     isEqual(other: T): boolean;
 }
+export interface Iterable<V> {
+    forEach: (cb: (v: V) => void) => void;
+}
 /** Helper to compare arrays using isEqual(). */
 export declare function arrayEquals<T>(left: T[], right: T[], comparator: (l: T, r: T) => boolean): boolean;
 /**

package/dist/lite/packages/firestore/test/unit/local/counting_query_engine.d.ts

@@ -16,6 +16,7 @@
  */
 import { Query } from '../../../src/core/query';
 import { SnapshotVersion } from '../../../src/core/snapshot_version';
+import { IndexManager } from '../../../src/local/index_manager';
 import { LocalDocumentsView } from '../../../src/local/local_documents_view';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
 import { PersistenceTransaction } from '../../../src/local/persistence_transaction';
@@ -51,7 +52,7 @@ export declare class CountingQueryEngine extends QueryEngine {
     documentsReadByKey: number;
     resetCounts(): void;
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, lastLimboFreeSnapshotVersion: SnapshotVersion, remoteKeys: DocumentKeySet): PersistencePromise<DocumentMap>;
-    setLocalDocumentsView(localDocuments: LocalDocumentsView): void;
+    initialize(localDocuments: LocalDocumentsView, indexManager: IndexManager): void;
     private wrapRemoteDocumentCache;
     private wrapMutationQueue;
 }

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

@@ -31,6 +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>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
     getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
     getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;

package/dist/lite/packages/firestore/test/unit/local/test_index_manager.d.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { Target } from '../../../src/core/target';
-import { IndexManager } from '../../../src/local/index_manager';
+import { IndexManager, IndexType } from '../../../src/local/index_manager';
 import { Persistence } from '../../../src/local/persistence';
 import { DocumentMap } from '../../../src/model/collections';
 import { DocumentKey } from '../../../src/model/document_key';
@@ -34,7 +34,7 @@ export declare class TestIndexManager {
     addFieldIndex(index: FieldIndex): Promise<void>;
     deleteFieldIndex(index: FieldIndex): Promise<void>;
     getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
-    getFieldIndex(target: Target): Promise<FieldIndex | null>;
+    getIndexType(target: Target): Promise<IndexType>;
     getDocumentsMatchingTarget(target: Target): Promise<DocumentKey[] | null>;
     getNextCollectionGroupToUpdate(): Promise<string | null>;
     updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;

package/dist/lite/packages/firestore/test/util/helpers.d.ts

@@ -69,6 +69,7 @@ export declare function blob(...bytes: number[]): Bytes;
 export declare function filter(path: string, op: string, value: unknown): FieldFilter;
 export declare function setMutation(keyStr: string, json: JsonObject<unknown>): SetMutation;
 export declare function patchMutation(keyStr: string, json: JsonObject<unknown>, precondition?: Precondition): PatchMutation;
+export declare function mergeMutation(keyStr: string, json: JsonObject<unknown>, updateMask: FieldPath[]): PatchMutation;
 export declare function deleteMutation(keyStr: string): DeleteMutation;
 export declare function mutationResult(testVersion: TestSnapshotVersion): MutationResult;
 export declare function bound(values: unknown[], inclusive: boolean): Bound;
@@ -177,3 +178,14 @@ export declare function expectSetToEqual<T>(set: SortedSet<T>, arr: T[]): void;
 export declare function expectEqualitySets<T>(elems: T[][], equalityFn: (v1: T, v2: T) => boolean, stringifyFn?: (v: T) => string): void;
 export declare function validateFirestoreError(expectedCode: Code, actualError: Error): void;
 export declare function forEachNumber<V>(obj: Dict<V>, fn: (key: number, val: V) => void): void;
+/**
+ * Returns all possible permutations of the given array.
+ * For `[a, b]`, this method returns `[[a, b], [b, a]]`.
+ */
+export declare function computePermutations<T>(input: T[]): T[][];
+/**
+ * Returns all possible combinations of the given array, including an empty
+ * array. For `[a, b, c]` this method returns
+ * `[[], [a], [a, b], [a, c], [b, c], [a, b, c]`.
+ */
+export declare function computeCombinations<T>(input: T[]): T[][];