@firebase/firestore 4.7.9-canary.a24a76aa2 → 4.7.9-canary.cf3c8fb2a

package/dist/index.node.mjs

@@ -9,7 +9,7 @@ import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "4.7.9-canary.a24a76aa2";
+const version$1 = "4.7.9-canary.cf3c8fb2a";
 
 /**
  * @license
@@ -62,7 +62,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.4.0-canary.a24a76aa2";
+const version = "11.4.0-canary.cf3c8fb2a";
 
 /**
  * @license
@@ -820,6 +820,35 @@ 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();
+}
+/**
+ * An instance of the Platform's 'TextDecoder' implementation.
+ */
+function newTextDecoder() {
+    return new TextDecoder('utf-8');
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -872,6 +901,63 @@ function primitiveComparator(left, right) {
     }
     return 0;
 }
+/** Compare strings in UTF-8 encoded byte order */
+function compareUtf8Strings(left, right) {
+    let i = 0;
+    while (i < left.length && i < right.length) {
+        const leftCodePoint = left.codePointAt(i);
+        const rightCodePoint = right.codePointAt(i);
+        if (leftCodePoint !== rightCodePoint) {
+            if (leftCodePoint < 128 && rightCodePoint < 128) {
+                // ASCII comparison
+                return primitiveComparator(leftCodePoint, rightCodePoint);
+            }
+            else {
+                // Lazy instantiate TextEncoder
+                const encoder = newTextEncoder();
+                // UTF-8 encode the character at index i for byte comparison.
+                const leftBytes = encoder.encode(getUtf8SafeSubstring(left, i));
+                const rightBytes = encoder.encode(getUtf8SafeSubstring(right, i));
+                const comp = compareByteArrays$1(leftBytes, rightBytes);
+                if (comp !== 0) {
+                    return comp;
+                }
+                else {
+                    // EXTREMELY RARE CASE: Code points differ, but their UTF-8 byte
+                    // representations are identical. This can happen with malformed input
+                    // (invalid surrogate pairs). The backend also actively prevents invalid
+                    // surrogates as INVALID_ARGUMENT errors, so we almost never receive
+                    // invalid strings from backend.
+                    // Fallback to code point comparison for graceful handling.
+                    return primitiveComparator(leftCodePoint, rightCodePoint);
+                }
+            }
+        }
+        // Increment by 2 for surrogate pairs, 1 otherwise
+        i += leftCodePoint > 0xffff ? 2 : 1;
+    }
+    // Compare lengths if all characters are equal
+    return primitiveComparator(left.length, right.length);
+}
+function getUtf8SafeSubstring(str, index) {
+    const firstCodePoint = str.codePointAt(index);
+    if (firstCodePoint > 0xffff) {
+        // It's a surrogate pair, return the whole pair
+        return str.substring(index, index + 2);
+    }
+    else {
+        // It's a single code point, return it
+        return str.substring(index, index + 1);
+    }
+}
+function compareByteArrays$1(left, right) {
+    for (let i = 0; i < left.length && i < right.length; ++i) {
+        if (left[i] !== right[i]) {
+            return primitiveComparator(left[i], right[i]);
+        }
+    }
+    return primitiveComparator(left.length, right.length);
+}
 /** Helper to compare arrays using isEqual(). */
 function arrayEquals(left, right, comparator) {
     if (left.length !== right.length) {
@@ -1233,7 +1319,7 @@ class BasePath {
                 return comparison;
             }
         }
-        return Math.sign(p1.length - p2.length);
+        return primitiveComparator(p1.length, p2.length);
     }
     static compareSegments(lhs, rhs) {
         const isLhsNumeric = BasePath.isNumericId(lhs);
@@ -1252,13 +1338,7 @@ class BasePath {
         }
         else {
             // both non-numeric
-            if (lhs < rhs) {
-                return -1;
-            }
-            if (lhs > rhs) {
-                return 1;
-            }
-            return 0;
+            return compareUtf8Strings(lhs, rhs);
         }
     }
     // Checks if a segment is a numeric ID (starts with "__id" and ends with "__").
@@ -4675,7 +4755,7 @@ function valueCompare(left, right) {
         case 4 /* TypeOrder.ServerTimestampValue */:
             return compareTimestamps(getLocalWriteTime(left), getLocalWriteTime(right));
         case 5 /* TypeOrder.StringValue */:
-            return primitiveComparator(left.stringValue, right.stringValue);
+            return compareUtf8Strings(left.stringValue, right.stringValue);
         case 6 /* TypeOrder.BlobValue */:
             return compareBlobs(left.bytesValue, right.bytesValue);
         case 7 /* TypeOrder.RefValue */:
@@ -4796,7 +4876,7 @@ function compareMaps(left, right) {
     leftKeys.sort();
     rightKeys.sort();
     for (let i = 0; i < leftKeys.length && i < rightKeys.length; ++i) {
-        const keyCompare = primitiveComparator(leftKeys[i], rightKeys[i]);
+        const keyCompare = compareUtf8Strings(leftKeys[i], rightKeys[i]);
         if (keyCompare !== 0) {
             return keyCompare;
         }
@@ -7977,35 +8057,6 @@ function setTestingHooksSpi(instance) {
     testingHooksSpi = instance;
 }
 
-/**
- * @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();
-}
-/**
- * An instance of the Platform's 'TextDecoder' implementation.
- */
-function newTextDecoder() {
-    return new TextDecoder('utf-8');
-}
-
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -14054,6 +14105,10 @@ function dbKeyComparator(l, r) {
     if (cmp) {
         return cmp;
     }
+    // TODO(b/329441702): Document IDs should be sorted by UTF-8 encoded byte
+    // order, but IndexedDB sorts strings lexicographically. Document ID
+    // comparison here still relies on primitive comparison to avoid mismatches
+    // observed in snapshot listeners with Unicode characters in documentIds
     return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }