@firebase/firestore 4.7.5 → 4.7.6-canary.144bc3709

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.5";
+const version$1 = "4.7.6-canary.144bc3709";
 
 /**
  * @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.0.2";
+const version = "11.2.0-canary.144bc3709";
 
 /**
  * @license
@@ -1213,25 +1213,53 @@ class BasePath {
     toArray() {
         return this.segments.slice(this.offset, this.limit());
     }
+    /**
+     * Compare 2 paths segment by segment, prioritizing numeric IDs
+     * (e.g., "__id123__") in numeric ascending order, followed by string
+     * segments in lexicographical order.
+     */
     static comparator(p1, p2) {
         const len = Math.min(p1.length, p2.length);
         for (let i = 0; i < len; i++) {
-            const left = p1.get(i);
-            const right = p2.get(i);
-            if (left < right) {
-                return -1;
-            }
-            if (left > right) {
-                return 1;
+            const comparison = BasePath.compareSegments(p1.get(i), p2.get(i));
+            if (comparison !== 0) {
+                return comparison;
             }
         }
-        if (p1.length < p2.length) {
+        return Math.sign(p1.length - p2.length);
+    }
+    static compareSegments(lhs, rhs) {
+        const isLhsNumeric = BasePath.isNumericId(lhs);
+        const isRhsNumeric = BasePath.isNumericId(rhs);
+        if (isLhsNumeric && !isRhsNumeric) {
+            // Only lhs is numeric
             return -1;
         }
-        if (p1.length > p2.length) {
+        else if (!isLhsNumeric && isRhsNumeric) {
+            // Only rhs is numeric
             return 1;
         }
-        return 0;
+        else if (isLhsNumeric && isRhsNumeric) {
+            // both numeric
+            return BasePath.extractNumericId(lhs).compare(BasePath.extractNumericId(rhs));
+        }
+        else {
+            // both non-numeric
+            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 "__").
+    static isNumericId(segment) {
+        return segment.startsWith('__id') && segment.endsWith('__');
+    }
+    static extractNumericId(segment) {
+        return Integer.fromString(segment.substring(4, segment.length - 2));
     }
 }
 /**
@@ -14981,6 +15009,10 @@ class MemoryMutationQueue {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * The smallest value representable by a 64-bit signed integer (long).
+ */
+const MIN_LONG_VALUE = '-9223372036854775808';
 function documentEntryMap() {
     return new SortedMap(DocumentKey.comparator);
 }
@@ -15056,7 +15088,10 @@ class MemoryRemoteDocumentCacheImpl {
         // Documents are ordered by key, so we can use a prefix scan to narrow down
         // the documents we need to match the query against.
         const collectionPath = query.path;
-        const prefix = new DocumentKey(collectionPath.child(''));
+        // Document keys are ordered first by numeric value ("__id<Long>__"),
+        // then lexicographically by string value. Start the iterator at the minimum
+        // possible Document key value.
+        const prefix = new DocumentKey(collectionPath.child('__id' + MIN_LONG_VALUE + '__'));
         const iterator = this.docs.getIteratorFrom(prefix);
         while (iterator.hasNext()) {
             const { key, value: { document } } = iterator.getNext();