@firebase/firestore 3.4.8-canary.aa41fd662 → 3.4.8-canary.d8be8bf1c

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.aa41fd662";
+const version$1 = "3.4.8-canary.d8be8bf1c";
 
 /**
  * @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.aa41fd662";
+const version = "9.6.11-canary.d8be8bf1c";
 
 /**
  * @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;
                 }
@@ -5832,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);
@@ -10194,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)
@@ -10232,19 +10237,15 @@ 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);
+            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));
@@ -10261,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
@@ -10362,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. */