@firebase/firestore 3.4.1-canary.be7ccb8ed → 3.4.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @firebase/firestore
 
+## 3.4.2
+
+### Patch Changes
+
+- [`3b481f572`](https://github.com/firebase/firebase-js-sdk/commit/3b481f572456e1eab3435bfc25717770d95a8c49) [#5831](https://github.com/firebase/firebase-js-sdk/pull/5831) (fixes [#5754](https://github.com/firebase/firebase-js-sdk/issues/5754)) - FirestoreError and StorageError now extend FirebaseError
+
+* [`7f05d22e8`](https://github.com/firebase/firebase-js-sdk/commit/7f05d22e827f1fd0732ad33fda203a20566d3964) [#5835](https://github.com/firebase/firebase-js-sdk/pull/5835) - Fixed an issue that can cause incomplete Query snapshots when the SDK is backgrounded during query execution.
+
+* Updated dependencies [[`3b481f572`](https://github.com/firebase/firebase-js-sdk/commit/3b481f572456e1eab3435bfc25717770d95a8c49)]:
+  - @firebase/util@1.4.3
+  - @firebase/component@0.5.10
+
 ## 3.4.1
 
 ### Patch Changes

package/dist/firestore/test/util/helpers.d.ts

@@ -71,6 +71,7 @@ export declare function bound(values: Array<[string, {}, firestore.OrderByDirect
 export declare function query(resourcePath: string, ...constraints: Array<OrderBy | Filter>): Query;
 export declare function targetData(targetId: TargetId, queryPurpose: TargetPurpose, path: string): TargetData;
 export declare function noChangeEvent(targetId: number, snapshotVersion: number, resumeToken?: ByteString): RemoteEvent;
+export declare function existenceFilterEvent(targetId: number, count: number, snapshotVersion: number): RemoteEvent;
 export declare function docAddedRemoteEvent(docOrDocs: MutableDocument | MutableDocument[], updatedInTargets?: TargetId[], removedFromTargets?: TargetId[], activeTargets?: TargetId[]): RemoteEvent;
 export declare function docUpdateRemoteEvent(doc: MutableDocument, updatedInTargets?: TargetId[], removedFromTargets?: TargetId[], limboTargets?: TargetId[]): RemoteEvent;
 export declare class TestBundledDocuments {

package/dist/index.esm2017.js

@@ -66,7 +66,7 @@ C.MOCK_USER = new C("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let N = "9.6.1-canary.be7ccb8ed";
+let N = "9.6.2";
 
 /**
  * @license
@@ -9016,21 +9016,19 @@ function mr(t) {
         // Reset newTargetDataByTargetMap in case this transaction gets re-run.
                 i = n.qn;
         const o = [];
-        e.targetChanges.forEach(((e, r) => {
-            const a = i.get(r);
-            if (!a) return;
+        e.targetChanges.forEach(((r, a) => {
+            const c = i.get(a);
+            if (!c) return;
             // Only update the remote keys if the target is still active. This
             // ensures that we can persist the updated target data along with
             // the updated assignment.
-                        o.push(n.He.removeMatchingKeys(t, e.removedDocuments, r).next((() => n.He.addMatchingKeys(t, e.addedDocuments, r))));
-            const c = e.resumeToken;
-            // Update the resume token if the change includes one.
-                        if (c.approximateByteSize() > 0) {
-                const u = a.withResumeToken(c, s).withSequenceNumber(t.currentSequenceNumber);
-                i = i.insert(r, u), 
-                // Update the target data if there are target changes (or if
-                // sufficient time has passed since the last update).
-                /**
+                        o.push(n.He.removeMatchingKeys(t, r.removedDocuments, a).next((() => n.He.addMatchingKeys(t, r.addedDocuments, a))));
+            let u = c.withSequenceNumber(t.currentSequenceNumber);
+            e.targetMismatches.has(a) ? u = u.withResumeToken(pt.EMPTY_BYTE_STRING, ut.min()).withLastLimboFreeSnapshotVersion(ut.min()) : r.resumeToken.approximateByteSize() > 0 && (u = u.withResumeToken(r.resumeToken, s)), 
+            i = i.insert(a, u), 
+            // Update the target data if there are target changes (or if
+            // sufficient time has passed since the last update).
+            /**
  * Returns true if the newTargetData should be persisted during an update of
  * an active target. TargetData should always be persisted when a target is
  * being released and should not call this function.
@@ -9041,26 +9039,25 @@ function mr(t) {
  * values from getting too stale after a crash, but this doesn't have to be
  * too frequent.
  */
-                function(t, e, n) {
-                    // Always persist target data if we don't already have a resume token.
-                    if (U(e.resumeToken.approximateByteSize() > 0), 0 === t.resumeToken.approximateByteSize()) return !0;
-                    // Don't allow resume token changes to be buffered indefinitely. This
-                    // allows us to be reasonably up-to-date after a crash and avoids needing
-                    // to loop over all active queries on shutdown. Especially in the browser
-                    // we may not get time to do anything interesting while the current tab is
-                    // closing.
-                                        if (e.snapshotVersion.toMicroseconds() - t.snapshotVersion.toMicroseconds() >= 3e8) return !0;
-                    // Otherwise if the only thing that has changed about a target is its resume
-                    // token it's not worth persisting. Note that the RemoteStore keeps an
-                    // in-memory view of the currently active targets which includes the current
-                    // resume token, so stream failure or user changes will still use an
-                    // up-to-date resume token regardless of what we do here.
-                                        return n.addedDocuments.size + n.modifiedDocuments.size + n.removedDocuments.size > 0;
-                }
-                /**
- * Notifies local store of the changed views to locally pin documents.
- */ (a, u, e) && o.push(n.He.updateTargetData(t, u));
+            function(t, e, n) {
+                // Always persist target data if we don't already have a resume token.
+                if (0 === t.resumeToken.approximateByteSize()) return !0;
+                // Don't allow resume token changes to be buffered indefinitely. This
+                // allows us to be reasonably up-to-date after a crash and avoids needing
+                // to loop over all active queries on shutdown. Especially in the browser
+                // we may not get time to do anything interesting while the current tab is
+                // closing.
+                                if (e.snapshotVersion.toMicroseconds() - t.snapshotVersion.toMicroseconds() >= 3e8) return !0;
+                // Otherwise if the only thing that has changed about a target is its resume
+                // token it's not worth persisting. Note that the RemoteStore keeps an
+                // in-memory view of the currently active targets which includes the current
+                // resume token, so stream failure or user changes will still use an
+                // up-to-date resume token regardless of what we do here.
+                                return n.addedDocuments.size + n.modifiedDocuments.size + n.removedDocuments.size > 0;
             }
+            /**
+ * Notifies local store of the changed views to locally pin documents.
+ */ (c, u, r) && o.push(n.He.updateTargetData(t, u));
         }));
         let a = Rn();
         // HACK: The only reason we allow a null snapshot version is so that we
@@ -17844,9 +17841,9 @@ function Ah(t, e) {
         return n = Object.assign({
             useFetchStreams: e
         }, n), i._setSettings(n), i;
-    }), "PUBLIC")), registerVersion(D, "3.4.1-canary.be7ccb8ed", t), 
+    }), "PUBLIC")), registerVersion(D, "3.4.2", t), 
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    registerVersion(D, "3.4.1-canary.be7ccb8ed", "esm2017");
+    registerVersion(D, "3.4.2", "esm2017");
 }();
 
 export { oh as AbstractUserDataWriter, nu as Bytes, Fc as CACHE_SIZE_UNLIMITED, Vc as CollectionReference, Pc as DocumentReference, $u as DocumentSnapshot, tu as FieldPath, su as FieldValue, Mc as Firestore, Q as FirestoreError, iu as GeoPoint, Oc as LoadBundleTask, vc as Query, Uu as QueryConstraint, Ou as QueryDocumentSnapshot, Fu as QuerySnapshot, xu as SnapshotMetadata, ct as Timestamp, Ph as Transaction, uh as WriteBatch, wc as _DatabaseId, Dt as _DocumentKey, et as _EmptyAppCheckTokenProvider, z as _EmptyAuthCredentialsProvider, mt as _FieldPath, Ec as _cast, q as _debugAssert, yt as _isBase64Available, M as _logWarn, gc as _validateIsNotUsedTogether, Eh as addDoc, Ch as arrayRemove, Dh as arrayUnion, Wc as clearIndexedDbPersistence, Sc as collection, Dc as collectionGroup, bc as connectFirestoreEmulator, Th as deleteDoc, Vh as deleteField, Hc as disableNetwork, Cc as doc, eu as documentId, Kc as enableIndexedDbPersistence, jc as enableMultiTabIndexedDbPersistence, zc as enableNetwork, eh as endAt, th as endBefore, Uc as ensureFirestoreConfigured, Rh as executeWrite, lh as getDoc, dh as getDocFromCache, wh as getDocFromServer, _h as getDocs, mh as getDocsFromCache, gh as getDocsFromServer, Bc as getFirestore, Nh as increment, Lc as initializeFirestore, zu as limit, Hu as limitToLast, Yc as loadBundle, Xc as namedQuery, Ih as onSnapshot, Ah as onSnapshotsInSync, Wu as orderBy, qu as query, kc as queryEqual, Nc as refEqual, vh as runTransaction, Sh as serverTimestamp, yh as setDoc, $ as setLogLevel, Lu as snapshotEqual, Xu as startAfter, Yu as startAt, Jc as terminate, ph as updateDoc, Gc as waitForPendingWrites, ju as where, kh as writeBatch };