@firebase/firestore 3.4.5 → 3.4.6-canary.3198d58dc

package/dist/lite/index.node.mjs

@@ -6,7 +6,7 @@ import { FirebaseError, createMockUserToken, getModularInstance } from '@firebas
 import nodeFetch from 'node-fetch';
 import { randomBytes as randomBytes$1 } from 'crypto';
 
-const version$1 = "3.4.5";
+const version$1 = "3.4.6-canary.3198d58dc";
 
 /**
  * @license
@@ -59,7 +59,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.7";
+const version = "9.6.9-canary.3198d58dc";
 
 /**
  * @license
@@ -1753,6 +1753,9 @@ class SnapshotVersion {
     static min() {
         return new SnapshotVersion(new Timestamp(0, 0));
     }
+    static max() {
+        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
+    }
     compareTo(other) {
         return this.timestamp._compareTo(other.timestamp);
     }
@@ -1881,17 +1884,15 @@ class FieldMask {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 function decodeBase64(encoded) {
-    // Node actually doesn't validate base64 strings.
-    // A quick sanity check that is not a fool-proof validation
-    if (/[^-A-Za-z0-9+/=]/.test(encoded)) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Not a valid Base64 string: ' + encoded);
-    }
-    return new Buffer(encoded, 'base64').toString('binary');
+    // Note: We used to validate the base64 string here via a regular expression.
+    // This was removed to improve the performance of indexing.
+    return Buffer.from(encoded, 'base64').toString('binary');
 }
 /** Converts a binary string to a Base64 encoded string. */
 function encodeBase64(raw) {
-    return new Buffer(raw, 'binary').toString('base64');
+    return Buffer.from(raw, 'binary').toString('base64');
 }
 
 /**
@@ -1928,6 +1929,8 @@ class ByteString {
         return new ByteString(binaryString);
     }
     static fromUint8Array(array) {
+        // TODO(indexing); Remove the copy of the byte string here as this method
+        // is frequently called during indexing.
         const binaryString = binaryStringFromUint8Array(array);
         return new ByteString(binaryString);
     }
@@ -2182,6 +2185,7 @@ function isSafeInteger(value) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const MAX_VALUE_TYPE = '__max__';
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -2215,6 +2219,9 @@ function typeOrder(value) {
         if (isServerTimestamp(value)) {
             return 4 /* ServerTimestampValue */;
         }
+        else if (isMaxValue(value)) {
+            return 9 /* ArrayValue */;
+        }
         return 10 /* ObjectValue */;
     }
     else {
@@ -2254,6 +2261,8 @@ function valueEquals(left, right) {
             return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
         case 10 /* ObjectValue */:
             return objectEquals(left, right);
+        case 9007199254740991 /* MaxValue */:
+            return true;
         default:
             return fail();
     }
@@ -2326,6 +2335,7 @@ function valueCompare(left, right) {
     }
     switch (leftType) {
         case 0 /* NullValue */:
+        case 9007199254740991 /* MaxValue */:
             return 0;
         case 1 /* BooleanValue */:
             return primitiveComparator(left.booleanValue, right.booleanValue);
@@ -2490,6 +2500,11 @@ function deepClone(source) {
     else {
         return Object.assign({}, source);
     }
+}
+/** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
+function isMaxValue(value) {
+    return ((((value.mapValue || {}).fields || {})['__type__'] || {}).stringValue ===
+        MAX_VALUE_TYPE);
 }
 
 /**