@firebase/firestore 4.7.7 → 4.7.8

package/dist/lite/index.node.mjs

@@ -6,7 +6,7 @@ import { FirebaseError, getDefaultEmulatorHostnameAndPort, createMockUserToken,
 import { Integer } from '@firebase/webchannel-wrapper/bloom-blob';
 import { randomBytes as randomBytes$1 } from 'crypto';
 
-const version$1 = "4.7.7";
+const version$1 = "4.7.8";
 
 /**
  * @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 = "11.3.0";
+const version = "11.3.1";
 
 /**
  * @license
@@ -699,127 +699,6 @@ function databaseIdFromApp(app, database) {
     return new DatabaseId(app.options.projectId, database);
 }
 
-/**
- * @license
- * Copyright 2020 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.
- */
-/**
- * Generates `nBytes` of random bytes.
- *
- * If `nBytes < 0` , an error will be thrown.
- */
-function randomBytes(nBytes) {
-    return randomBytes$1(nBytes);
-}
-
-/**
- * @license
- * Copyright 2023 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.
- */
-/**
- * An instance of the Platform's 'TextEncoder' implementation.
- */
-function newTextEncoder() {
-    return new TextEncoder();
-}
-
-/**
- * @license
- * Copyright 2017 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.
- */
-/**
- * A utility class for generating unique alphanumeric IDs of a specified length.
- *
- * @internal
- * Exported internally for testing purposes.
- */
-class AutoId {
-    static newId() {
-        // Alphanumeric characters
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        // The largest byte value that is a multiple of `char.length`.
-        const maxMultiple = Math.floor(256 / chars.length) * chars.length;
-        let autoId = '';
-        const targetLength = 20;
-        while (autoId.length < targetLength) {
-            const bytes = randomBytes(40);
-            for (let i = 0; i < bytes.length; ++i) {
-                // Only accept values that are [0, maxMultiple), this ensures they can
-                // be evenly mapped to indices of `chars` via a modulo operation.
-                if (autoId.length < targetLength && bytes[i] < maxMultiple) {
-                    autoId += chars.charAt(bytes[i] % chars.length);
-                }
-            }
-        }
-        return autoId;
-    }
-}
-function primitiveComparator(left, right) {
-    if (left < right) {
-        return -1;
-    }
-    if (left > right) {
-        return 1;
-    }
-    return 0;
-}
-/** Compare strings in UTF-8 encoded byte order */
-function compareUtf8Strings(left, right) {
-    // Convert the string to UTF-8 encoded bytes
-    const encodedLeft = newTextEncoder().encode(left);
-    const encodedRight = newTextEncoder().encode(right);
-    for (let i = 0; i < Math.min(encodedLeft.length, encodedRight.length); i++) {
-        const comparison = primitiveComparator(encodedLeft[i], encodedRight[i]);
-        if (comparison !== 0) {
-            return comparison;
-        }
-    }
-    return primitiveComparator(encodedLeft.length, encodedRight.length);
-}
-/** Helper to compare arrays using isEqual(). */
-function arrayEquals(left, right, comparator) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    return left.every((value, index) => comparator(value, right[index]));
-}
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -942,7 +821,7 @@ class BasePath {
                 return comparison;
             }
         }
-        return primitiveComparator(p1.length, p2.length);
+        return Math.sign(p1.length - p2.length);
     }
     static compareSegments(lhs, rhs) {
         const isLhsNumeric = BasePath.isNumericId(lhs);
@@ -961,7 +840,13 @@ class BasePath {
         }
         else {
             // both non-numeric
-            return compareUtf8Strings(lhs, rhs);
+            if (lhs < rhs) {
+                return -1;
+            }
+            if (lhs > rhs) {
+                return 1;
+            }
+            return 0;
         }
     }
     // Checks if a segment is a numeric ID (starts with "__id" and ends with "__").
@@ -1761,6 +1646,91 @@ function newConnection(databaseInfo) {
     return new FetchConnection(databaseInfo);
 }
 
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+/**
+ * Generates `nBytes` of random bytes.
+ *
+ * If `nBytes < 0` , an error will be thrown.
+ */
+function randomBytes(nBytes) {
+    return randomBytes$1(nBytes);
+}
+
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+/**
+ * A utility class for generating unique alphanumeric IDs of a specified length.
+ *
+ * @internal
+ * Exported internally for testing purposes.
+ */
+class AutoId {
+    static newId() {
+        // Alphanumeric characters
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        // The largest byte value that is a multiple of `char.length`.
+        const maxMultiple = Math.floor(256 / chars.length) * chars.length;
+        let autoId = '';
+        const targetLength = 20;
+        while (autoId.length < targetLength) {
+            const bytes = randomBytes(40);
+            for (let i = 0; i < bytes.length; ++i) {
+                // Only accept values that are [0, maxMultiple), this ensures they can
+                // be evenly mapped to indices of `chars` via a modulo operation.
+                if (autoId.length < targetLength && bytes[i] < maxMultiple) {
+                    autoId += chars.charAt(bytes[i] % chars.length);
+                }
+            }
+        }
+        return autoId;
+    }
+}
+function primitiveComparator(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}
+/** Helper to compare arrays using isEqual(). */
+function arrayEquals(left, right, comparator) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => comparator(value, right[index]));
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -2474,7 +2444,7 @@ function valueCompare(left, right) {
         case 4 /* TypeOrder.ServerTimestampValue */:
             return compareTimestamps(getLocalWriteTime(left), getLocalWriteTime(right));
         case 5 /* TypeOrder.StringValue */:
-            return compareUtf8Strings(left.stringValue, right.stringValue);
+            return primitiveComparator(left.stringValue, right.stringValue);
         case 6 /* TypeOrder.BlobValue */:
             return compareBlobs(left.bytesValue, right.bytesValue);
         case 7 /* TypeOrder.RefValue */:
@@ -2595,7 +2565,7 @@ function compareMaps(left, right) {
     leftKeys.sort();
     rightKeys.sort();
     for (let i = 0; i < leftKeys.length && i < rightKeys.length; ++i) {
-        const keyCompare = compareUtf8Strings(leftKeys[i], rightKeys[i]);
+        const keyCompare = primitiveComparator(leftKeys[i], rightKeys[i]);
         if (keyCompare !== 0) {
             return keyCompare;
         }