@firebase/firestore 3.4.8-canary.7b58dabdf → 3.4.8-canary.874cdbbcc

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.8-canary.7b58dabdf";
+const version$1 = "3.4.8-canary.874cdbbcc";
 
 /**
  * @license
@@ -61,7 +61,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.6.11-canary.7b58dabdf";
+const version = "9.7.0-canary.874cdbbcc";
 
 /**
  * @license
@@ -3321,7 +3321,7 @@ function typeOrder(value) {
             return 4 /* ServerTimestampValue */;
         }
         else if (isMaxValue(value)) {
-            return 9 /* ArrayValue */;
+            return 9007199254740991 /* MaxValue */;
         }
         return 10 /* ObjectValue */;
     }
@@ -3533,6 +3533,15 @@ function compareArrays(left, right) {
     return primitiveComparator(leftArray.length, rightArray.length);
 }
 function compareMaps(left, right) {
+    if (left === MAX_VALUE.mapValue && right === MAX_VALUE.mapValue) {
+        return 0;
+    }
+    else if (left === MAX_VALUE.mapValue) {
+        return 1;
+    }
+    else if (right === MAX_VALUE.mapValue) {
+        return -1;
+    }
     const leftMap = left.fields || {};
     const leftKeys = Object.keys(leftMap);
     const rightMap = right.fields || {};
@@ -3780,27 +3789,31 @@ function valuesGetUpperBound(value) {
         return fail();
     }
 }
-function valuesMax(left, right) {
-    if (left === undefined) {
-        return right;
+function lowerBoundCompare(left, right) {
+    const cmp = valueCompare(left.value, right.value);
+    if (cmp !== 0) {
+        return cmp;
     }
-    else if (right === undefined) {
-        return left;
+    if (left.inclusive && !right.inclusive) {
+        return -1;
     }
-    else {
-        return valueCompare(left, right) > 0 ? left : right;
+    else if (!left.inclusive && right.inclusive) {
+        return 1;
     }
+    return 0;
 }
-function valuesMin(left, right) {
-    if (left === undefined) {
-        return right;
+function upperBoundCompare(left, right) {
+    const cmp = valueCompare(left.value, right.value);
+    if (cmp !== 0) {
+        return cmp;
     }
-    else if (right === undefined) {
-        return left;
+    if (left.inclusive && !right.inclusive) {
+        return 1;
     }
-    else {
-        return valueCompare(left, right) < 0 ? left : right;
+    else if (!left.inclusive && right.inclusive) {
+        return -1;
     }
+    return 0;
 }
 
 /**
@@ -5184,7 +5197,7 @@ function targetGetNotInValues(target, fieldIndex) {
 }
 /**
  * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
  * exists.
  */
 function targetGetLowerBound(target, fieldIndex) {
@@ -5196,10 +5209,6 @@ function targetGetLowerBound(target, fieldIndex) {
         const segmentBound = segment.kind === 0 /* ASCENDING */
             ? targetGetAscendingBound(target, segment.fieldPath, target.startAt)
             : targetGetDescendingBound(target, segment.fieldPath, target.startAt);
-        if (!segmentBound.value) {
-            // No lower bound exists
-            return null;
-        }
         values.push(segmentBound.value);
         inclusive && (inclusive = segmentBound.inclusive);
     }
@@ -5207,7 +5216,7 @@ function targetGetLowerBound(target, fieldIndex) {
 }
 /**
  * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
  * upper bound exists.
  */
 function targetGetUpperBound(target, fieldIndex) {
@@ -5219,10 +5228,6 @@ function targetGetUpperBound(target, fieldIndex) {
         const segmentBound = segment.kind === 0 /* ASCENDING */
             ? targetGetDescendingBound(target, segment.fieldPath, target.endAt)
             : targetGetAscendingBound(target, segment.fieldPath, target.endAt);
-        if (!segmentBound.value) {
-            // No upper bound exists
-            return null;
-        }
         values.push(segmentBound.value);
         inclusive && (inclusive = segmentBound.inclusive);
     }
@@ -5233,11 +5238,11 @@ function targetGetUpperBound(target, fieldIndex) {
  * the provided `fieldPath` (or the upper bound for an descending segment).
  */
 function targetGetAscendingBound(target, fieldPath, bound) {
-    let value = undefined;
+    let value = MIN_VALUE;
     let inclusive = true;
     // Process all filters to find a value for the current field segment
     for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
-        let filterValue = undefined;
+        let filterValue = MIN_VALUE;
         let filterInclusive = true;
         switch (fieldFilter.op) {
             case "<" /* LESS_THAN */:
@@ -5259,7 +5264,7 @@ function targetGetAscendingBound(target, fieldPath, bound) {
                 break;
             // Remaining filters cannot be used as lower bounds.
         }
-        if (valuesMax(value, filterValue) === filterValue) {
+        if (lowerBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) < 0) {
             value = filterValue;
             inclusive = filterInclusive;
         }
@@ -5271,7 +5276,7 @@ function targetGetAscendingBound(target, fieldPath, bound) {
             const orderBy = target.orderBy[i];
             if (orderBy.field.isEqual(fieldPath)) {
                 const cursorValue = bound.position[i];
-                if (valuesMax(value, cursorValue) === cursorValue) {
+                if (lowerBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) < 0) {
                     value = cursorValue;
                     inclusive = bound.inclusive;
                 }
@@ -5286,11 +5291,11 @@ function targetGetAscendingBound(target, fieldPath, bound) {
  * the provided `fieldPath` (or the lower bound for a descending segment).
  */
 function targetGetDescendingBound(target, fieldPath, bound) {
-    let value = undefined;
+    let value = MAX_VALUE;
     let inclusive = true;
     // Process all filters to find a value for the current field segment
     for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
-        let filterValue = undefined;
+        let filterValue = MAX_VALUE;
         let filterInclusive = true;
         switch (fieldFilter.op) {
             case ">=" /* GREATER_THAN_OR_EQUAL */:
@@ -5313,7 +5318,7 @@ function targetGetDescendingBound(target, fieldPath, bound) {
                 break;
             // Remaining filters cannot be used as upper bounds.
         }
-        if (valuesMin(value, filterValue) === filterValue) {
+        if (upperBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) > 0) {
             value = filterValue;
             inclusive = filterInclusive;
         }
@@ -5325,7 +5330,7 @@ function targetGetDescendingBound(target, fieldPath, bound) {
             const orderBy = target.orderBy[i];
             if (orderBy.field.isEqual(fieldPath)) {
                 const cursorValue = bound.position[i];
-                if (valuesMin(value, cursorValue) === cursorValue) {
+                if (upperBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) > 0) {
                     value = cursorValue;
                     inclusive = bound.inclusive;
                 }
@@ -5714,7 +5719,7 @@ function asCollectionQueryAtPath(query, path) {
  * Returns true if this query does not specify any query constraints that
  * could remove results.
  */
-function matchesAllDocuments(query) {
+function queryMatchesAllDocuments(query) {
     return (query.filters.length === 0 &&
         query.limit === null &&
         query.startAt == null &&
@@ -5723,12 +5728,6 @@ function matchesAllDocuments(query) {
             (query.explicitOrderBy.length === 1 &&
                 query.explicitOrderBy[0].field.isKeyField())));
 }
-function hasLimitToFirst(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "F" /* First */;
-}
-function hasLimitToLast(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "L" /* Last */;
-}
 function getFirstOrderByField(query) {
     return query.explicitOrderBy.length > 0
         ? query.explicitOrderBy[0].field
@@ -5838,10 +5837,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
+                ? new Bound(queryImpl.endAt.position, queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
+                ? new Bound(queryImpl.startAt.position, queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -6112,8 +6111,12 @@ function mutableDocumentMap() {
     return EMPTY_MUTABLE_DOCUMENT_MAP;
 }
 const EMPTY_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);
-function documentMap() {
-    return EMPTY_DOCUMENT_MAP;
+function documentMap(...docs) {
+    let map = EMPTY_DOCUMENT_MAP;
+    for (const doc of docs) {
+        map = map.insert(doc.key, doc);
+    }
+    return map;
 }
 function newOverlayMap() {
     return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
@@ -10018,6 +10021,9 @@ class MemoryIndexManager {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve(null);
     }
+    getMinOffset(transaction, target) {
+        return PersistencePromise.resolve(IndexOffset.min());
+    }
     updateCollectionGroup(transaction, collectionGroup, offset) {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve();
@@ -10193,7 +10199,7 @@ class IndexedDbIndexManager {
                     const lowerBoundEncoded = this.encodeBound(index, subTarget, lowerBound);
                     const upperBoundEncoded = this.encodeBound(index, subTarget, upperBound);
                     const notInEncoded = this.encodeValues(index, subTarget, notInValues);
-                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, !!lowerBound && lowerBound.inclusive, upperBoundEncoded, !!upperBound && upperBound.inclusive, notInEncoded);
+                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, lowerBound.inclusive, upperBoundEncoded, upperBound.inclusive, notInEncoded);
                     return PersistencePromise.forEach(indexRanges, (indexRange) => {
                         return indexEntries
                             .loadFirst(indexRange, target.limit)
@@ -10231,22 +10237,18 @@ class IndexedDbIndexManager {
         // index range per value in an ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filter
         // combined with the values from the query bounds.
         const totalScans = (arrayValues != null ? arrayValues.length : 1) *
-            Math.max(lowerBounds != null ? lowerBounds.length : 1, upperBounds != null ? upperBounds.length : 1);
+            Math.max(lowerBounds.length, upperBounds.length);
         const scansPerArrayElement = totalScans / (arrayValues != null ? arrayValues.length : 1);
         const indexRanges = [];
         for (let i = 0; i < totalScans; ++i) {
             const arrayValue = arrayValues
                 ? this.encodeSingleElement(arrayValues[i / scansPerArrayElement])
                 : EMPTY_VALUE;
-            const lowerBound = lowerBounds
-                ? this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive)
-                : this.generateEmptyBound(indexId);
-            const upperBound = upperBounds
-                ? this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive)
-                : this.generateEmptyBound(indexId + 1);
-            indexRanges.push(...this.createRange(lowerBound, upperBound, notInValues.map((notIn // make non-nullable
-            ) => this.generateLowerBound(indexId, arrayValue, notIn, 
-            /* inclusive= */ true))));
+            const lowerBound = this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive);
+            const upperBound = this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive);
+            const notInBound = notInValues.map(notIn => this.generateLowerBound(indexId, arrayValue, notIn, 
+            /* inclusive= */ true));
+            indexRanges.push(...this.createRange(lowerBound, upperBound, notInBound));
         }
         return indexRanges;
     }
@@ -10260,13 +10262,6 @@ class IndexedDbIndexManager {
         const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
         return inclusive ? entry.successor() : entry;
     }
-    /**
-     * Generates an empty bound that scopes the index scan to the current index
-     * and user.
-     */
-    generateEmptyBound(indexId) {
-        return new IndexEntry(indexId, DocumentKey.empty(), EMPTY_VALUE, EMPTY_VALUE);
-    }
     getFieldIndex(transaction, target) {
         const targetIndexMatcher = new TargetIndexMatcher(target);
         const collectionGroup = target.collectionGroup != null
@@ -10286,15 +10281,18 @@ class IndexedDbIndexManager {
         });
     }
     getIndexType(transaction, target) {
-        // TODO(orqueries): We should look at the subtargets here
-        return this.getFieldIndex(transaction, target).next(index => {
-            if (!index) {
-                return 0 /* NONE */;
-            }
-            return index.fields.length < targetGetSegmentCount(target)
-                ? 1 /* PARTIAL */
-                : 2 /* FULL */;
-        });
+        let indexType = 2 /* FULL */;
+        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
+            return this.getFieldIndex(transaction, target).next(index => {
+                if (!index) {
+                    indexType = 0 /* NONE */;
+                }
+                else if (indexType !== 0 /* NONE */ &&
+                    index.fields.length < targetGetSegmentCount(target)) {
+                    indexType = 1 /* PARTIAL */;
+                }
+            });
+        }).next(() => indexType);
     }
     /**
      * Returns the byte encoded form of the directional values in the field index.
@@ -10358,9 +10356,6 @@ class IndexedDbIndexManager {
      * queries, a list of possible values is returned.
      */
     encodeBound(fieldIndex, target, bound) {
-        if (bound == null) {
-            return null;
-        }
         return this.encodeValues(fieldIndex, target, bound.position);
     }
     /** Returns the byte representation for the provided encoders. */
@@ -10555,7 +10550,7 @@ class IndexedDbIndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     createRange(lower, upper, notInValues) {
-        // The notIb values need to be sorted and unique so that we can return a
+        // The notIn values need to be sorted and unique so that we can return a
         // sorted set of non-overlapping ranges.
         notInValues = notInValues
             .sort((l, r) => indexEntryComparator(l, r))
@@ -10601,6 +10596,20 @@ class IndexedDbIndexManager {
         }
         return ranges;
     }
+    getMinOffset(transaction, target) {
+        let offset;
+        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
+            return this.getFieldIndex(transaction, target).next(index => {
+                if (!index) {
+                    offset = IndexOffset.min();
+                }
+                else if (!offset ||
+                    indexOffsetComparator(index.indexState.offset, offset) < 0) {
+                    offset = index.indexState.offset;
+                }
+            });
+        }).next(() => offset);
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -13771,7 +13780,7 @@ class LocalStoreImpl {
         this.mutationQueue = this.persistence.getMutationQueue(user, this.indexManager);
         this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.indexManager);
         this.remoteDocuments.setIndexManager(this.indexManager);
-        this.queryEngine.setLocalDocumentsView(this.localDocuments);
+        this.queryEngine.initialize(this.localDocuments, this.indexManager);
     }
     collectGarbage(garbageCollector) {
         return this.persistence.runTransaction('Collect garbage', 'readwrite-primary', txn => garbageCollector.collect(txn, this.targetDataByTarget));
@@ -15513,10 +15522,30 @@ class MemoryEagerDelegate {
  * limitations under the License.
  */
 /**
- * A query engine that takes advantage of the target document mapping in the
- * QueryCache. Query execution is optimized by only reading the documents that
- * previously matched a query plus any documents that were edited after the
- * query was last listened to.
+ * The Firestore query engine.
+ *
+ * Firestore queries can be executed in three modes. The Query Engine determines
+ * what mode to use based on what data is persisted. The mode only determines
+ * the runtime complexity of the query - the result set is equivalent across all
+ * implementations.
+ *
+ * The Query engine will use indexed-based execution if a user has configured
+ * any index that can be used to execute query (via `setIndexConfiguration()`).
+ * Otherwise, the engine will try to optimize the query by re-using a previously
+ * persisted query result. If that is not possible, the query will be executed
+ * via a full collection scan.
+ *
+ * Index-based execution is the default when available. The query engine
+ * supports partial indexed execution and merges the result from the index
+ * lookup with documents that have not yet been indexed. The index evaluation
+ * matches the backend's format and as such, the SDK can use indexing for all
+ * queries that the backend supports.
+ *
+ * If no index exists, the query engine tries to take advantage of the target
+ * document mapping in the TargetCache. These mappings exists for all queries
+ * that have been synced with the backend at least once and allow the query
+ * engine to only read documents that previously matched a query plus any
+ * documents that were edited after the query was last listened to.
  *
  * There are some cases when this optimization is not guaranteed to produce
  * the same results as full collection scans. In these cases, query
@@ -15531,16 +15560,41 @@ class MemoryEagerDelegate {
  * - Queries that have never been CURRENT or free of limbo documents.
  */
 class QueryEngine {
+    constructor() {
+        this.initialized = false;
+    }
     /** Sets the document view to query against. */
-    setLocalDocumentsView(localDocuments) {
+    initialize(localDocuments, indexManager) {
         this.localDocumentsView = localDocuments;
+        this.indexManager = indexManager;
+        this.initialized = true;
     }
     /** Returns all local documents matching the specified query. */
     getDocumentsMatchingQuery(transaction, query, lastLimboFreeSnapshotVersion, remoteKeys) {
-        // Queries that match all documents don't benefit from using
-        // key-based lookups. It is more efficient to scan all documents in a
-        // collection, rather than to perform individual lookups.
-        if (matchesAllDocuments(query)) {
+        return this.performQueryUsingIndex(transaction, query)
+            .next(result => result
+            ? result
+            : this.performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion))
+            .next(result => result ? result : this.executeFullCollectionScan(transaction, query));
+    }
+    /**
+     * Performs an indexed query that evaluates the query based on a collection's
+     * persisted index values. Returns `null` if an index is not available.
+     */
+    performQueryUsingIndex(transaction, query) {
+        {
+            return PersistencePromise.resolve(null);
+        }
+    }
+    /**
+     * Performs a query based on the target's persisted query mapping. Returns
+     * `null` if the mapping is not available or cannot be used.
+     */
+    performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion) {
+        if (queryMatchesAllDocuments(query)) {
+            // Queries that match all documents don't benefit from using
+            // key-based lookups. It is more efficient to scan all documents in a
+            // collection, rather than to perform individual lookups.
             return this.executeFullCollectionScan(transaction, query);
         }
         // Queries that have never seen a snapshot without limbo free documents
@@ -15550,8 +15604,7 @@ class QueryEngine {
         }
         return this.localDocumentsView.getDocuments(transaction, remoteKeys).next(documents => {
             const previousResults = this.applyQuery(query, documents);
-            if ((hasLimitToFirst(query) || hasLimitToLast(query)) &&
-                this.needsRefill(query.limitType, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
+            if (this.needsRefill(query, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
                 return this.executeFullCollectionScan(transaction, query);
             }
             if (getLogLevel() <= LogLevel.DEBUG) {
@@ -15559,15 +15612,7 @@ class QueryEngine {
             }
             // Retrieve all results for documents that were updated since the last
             // limbo-document free remote snapshot.
-            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next(updatedResults => {
-                // We merge `previousResults` into `updateResults`, since
-                // `updateResults` is already a DocumentMap. If a document is
-                // contained in both lists, then its contents are the same.
-                previousResults.forEach(doc => {
-                    updatedResults = updatedResults.insert(doc.key, doc);
-                });
-                return updatedResults;
-            });
+            return this.appendRemainingResults(transaction, previousResults, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID));
         });
     }
     /** Applies the query filter and sorting to the provided documents.  */
@@ -15586,6 +15631,7 @@ 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 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
@@ -15593,10 +15639,14 @@ class QueryEngine {
      * @param limboFreeSnapshotVersion - The version of the snapshot when the
      * query was last synchronized.
      */
-    needsRefill(limitType, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
-        // The query needs to be refilled if a previously matching document no
-        // longer matches.
+    needsRefill(query, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
+        if (query.limit === null) {
+            // Queries without limits do not need to be refilled.
+            return false;
+        }
         if (remoteKeys.size !== sortedPreviousResults.size) {
+            // The query needs to be refilled if a previously matching document no
+            // longer matches.
             return true;
         }
         // Limit queries are not eligible for index-free query execution if there is
@@ -15607,7 +15657,7 @@ class QueryEngine {
         // the boundary of the limit itself did not change and documents from cache
         // will continue to be "rejected" by this boundary. Therefore, we can ignore
         // any modifications that don't affect the last document.
-        const docAtLimitEdge = limitType === "F" /* First */
+        const docAtLimitEdge = query.limitType === "F" /* First */
             ? sortedPreviousResults.last()
             : sortedPreviousResults.first();
         if (!docAtLimitEdge) {
@@ -15623,6 +15673,22 @@ class QueryEngine {
         }
         return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, IndexOffset.min());
     }
+    /**
+     * Combines the results from an indexed execution with the remaining documents
+     * that have not yet been indexed.
+     */
+    appendRemainingResults(transaction, indexedResults, query, offset) {
+        // Retrieve all results for documents that were updated since the offset.
+        return this.localDocumentsView
+            .getDocumentsMatchingQuery(transaction, query, offset)
+            .next(remainingResults => {
+            // Merge with existing results
+            indexedResults.forEach(d => {
+                remainingResults = remainingResults.insert(d.key, d);
+            });
+            return remainingResults;
+        });
+    }
 }
 
 /**
@@ -21882,10 +21948,12 @@ class View {
         //
         // Note that this should never get used in a refill (when previousChanges is
         // set), because there will only be adds -- no deletes or updates.
-        const lastDocInLimit = hasLimitToFirst(this.query) && oldDocumentSet.size === this.query.limit
+        const lastDocInLimit = this.query.limitType === "F" /* First */ &&
+            oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.last()
             : null;
-        const firstDocInLimit = hasLimitToLast(this.query) && oldDocumentSet.size === this.query.limit
+        const firstDocInLimit = this.query.limitType === "L" /* Last */ &&
+            oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.first()
             : null;
         docChanges.inorderTraversal((key, entry) => {
@@ -21958,9 +22026,9 @@ class View {
             }
         });
         // Drop documents out to meet limit/limitToLast requirement.
-        if (hasLimitToFirst(this.query) || hasLimitToLast(this.query)) {
+        if (this.query.limit !== null) {
             while (newDocumentSet.size > this.query.limit) {
-                const oldDoc = hasLimitToFirst(this.query)
+                const oldDoc = this.query.limitType === "F" /* First */
                     ? newDocumentSet.last()
                     : newDocumentSet.first();
                 newDocumentSet = newDocumentSet.delete(oldDoc.key);
@@ -23961,18 +24029,18 @@ class Transaction$2 {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
 /**
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
  */
 class TransactionRunner {
-    constructor(asyncQueue, datastore, updateFunction, deferred) {
+    constructor(asyncQueue, datastore, options, updateFunction, deferred) {
         this.asyncQueue = asyncQueue;
         this.datastore = datastore;
+        this.options = options;
         this.updateFunction = updateFunction;
         this.deferred = deferred;
-        this.attemptsRemaining = DEFAULT_MAX_ATTEMPTS_COUNT;
+        this.attemptsRemaining = options.maxAttempts;
         this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */
@@ -24330,11 +24398,11 @@ function firestoreClientAddSnapshotsInSyncListener(client, observer) {
  * been committed. For this reason, it is required that all reads are
  * performed before any writes. Transactions must be performed while online.
  */
-function firestoreClientTransaction(client, updateFunction) {
+function firestoreClientTransaction(client, updateFunction, options) {
     const deferred = new Deferred();
     client.asyncQueue.enqueueAndForget(async () => {
         const datastore = await getDatastore(client);
-        new TransactionRunner(client.asyncQueue, datastore, updateFunction, deferred).run();
+        new TransactionRunner(client.asyncQueue, datastore, options, updateFunction, deferred).run();
     });
     return deferred.promise;
 }
@@ -27091,7 +27159,8 @@ function snapshotEqual(left, right) {
  * limitations under the License.
  */
 function validateHasExplicitOrderByForLimitToLast(query) {
-    if (hasLimitToLast(query) && query.explicitOrderBy.length === 0) {
+    if (query.limitType === "L" /* Last */ &&
+        query.explicitOrderBy.length === 0) {
         throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
     }
 }
@@ -27533,6 +27602,31 @@ function validateOrderByAndInequalityMatch(baseQuery, inequality, orderBy) {
     }
 }
 
+/**
+ * @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.
+ */
+const DEFAULT_TRANSACTION_OPTIONS = {
+    maxAttempts: 5
+};
+function validateTransactionOptions(options) {
+    if (options.maxAttempts < 1) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Max attempts must be at least 1');
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -28254,10 +28348,12 @@ class Transaction extends Transaction$1 {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-function runTransaction(firestore, updateFunction) {
+function runTransaction(firestore, updateFunction, options) {
     firestore = cast(firestore, Firestore);
+    const optionsWithDefaults = Object.assign(Object.assign({}, DEFAULT_TRANSACTION_OPTIONS), options);
+    validateTransactionOptions(optionsWithDefaults);
     const client = ensureFirestoreConfigured(firestore);
-    return firestoreClientTransaction(client, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)));
+    return firestoreClientTransaction(client, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), optionsWithDefaults);
 }
 
 /**