@firebase/firestore 3.12.0-20230511201449 → 3.12.0

package/dist/lite/index.browser.esm2017.js

@@ -63,7 +63,7 @@ d.MOCK_USER = new d("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let w = "9.22.0-20230511201449";
+let w = "9.22.0";
 
 /**
  * @license
@@ -4869,7 +4869,7 @@ function Gn(t) {
         });
     }
     ct(t) {
-        return wr(t, this.settings.methodName, this.settings.at || !1, this.path, this.settings.ht);
+        return wr(t, this.settings.methodName, this.settings.ht || !1, this.path, this.settings.lt);
     }
     /** Returns 'true' if 'fieldPath' was traversed when creating this context. */    contains(t) {
         return void 0 !== this.fieldMask.find((e => t.isPrefixOf(e))) || void 0 !== this.fieldTransforms.find((e => t.isPrefixOf(e.field)));
@@ -4892,14 +4892,14 @@ function Gn(t) {
     constructor(t, e, n) {
         this.databaseId = t, this.ignoreUndefinedProperties = e, this.serializer = n || wn(t);
     }
-    /** Creates a new top-level parse context. */    lt(t, e, n, r = !1) {
+    /** Creates a new top-level parse context. */    ft(t, e, n, r = !1) {
         return new Kn({
             et: t,
             methodName: e,
-            ht: n,
+            lt: n,
             path: nt.emptyPath(),
             st: !1,
-            at: r
+            ht: r
         }, this.databaseId, this.serializer, this.ignoreUndefinedProperties);
     }
 }
@@ -4910,7 +4910,7 @@ function Hn(t) {
 }
 
 /** Parse document data from a set() call. */ function Jn(t, e, n, r, s, i = {}) {
-    const o = t.lt(i.merge || i.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , e, n, s);
+    const o = t.ft(i.merge || i.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , e, n, s);
     hr("Data must be an object, but it was:", o, r);
     const u = cr(r, o);
     let c, a;
@@ -4956,7 +4956,7 @@ class Xn extends jn {
  */ function Zn(t, e, n) {
     return new Kn({
         et: 3 /* UserDataSource.Argument */ ,
-        ht: e.settings.ht,
+        lt: e.settings.lt,
         methodName: t._methodName,
         st: n
     }, e.databaseId, e.serializer, e.ignoreUndefinedProperties);
@@ -4973,11 +4973,11 @@ class tr extends jn {
 
 class er extends jn {
     constructor(t, e) {
-        super(t), this.ft = e;
+        super(t), this.dt = e;
     }
     _toFieldTransform(t) {
         const e = Zn(this, t, 
-        /*array=*/ !0), n = this.ft.map((t => ur(t, e))), r = new xe(n);
+        /*array=*/ !0), n = this.dt.map((t => ur(t, e))), r = new xe(n);
         return new Oe(t.path, r);
     }
     isEqual(t) {
@@ -4988,11 +4988,11 @@ class er extends jn {
 
 class nr extends jn {
     constructor(t, e) {
-        super(t), this.ft = e;
+        super(t), this.dt = e;
     }
     _toFieldTransform(t) {
         const e = Zn(this, t, 
-        /*array=*/ !0), n = this.ft.map((t => ur(t, e))), r = new Se(n);
+        /*array=*/ !0), n = this.dt.map((t => ur(t, e))), r = new Se(n);
         return new Oe(t.path, r);
     }
     isEqual(t) {
@@ -5003,10 +5003,10 @@ class nr extends jn {
 
 class rr extends jn {
     constructor(t, e) {
-        super(t), this.dt = e;
+        super(t), this.wt = e;
     }
     _toFieldTransform(t) {
-        const e = new qe(t.serializer, Ne(t.serializer, this.dt));
+        const e = new qe(t.serializer, Ne(t.serializer, this.wt));
         return new Oe(t.path, e);
     }
     isEqual(t) {
@@ -5016,7 +5016,7 @@ class rr extends jn {
 }
 
 /** Parse update data from an update() call. */ function sr(t, e, n, r) {
-    const s = t.lt(1 /* UserDataSource.Update */ , e, n);
+    const s = t.ft(1 /* UserDataSource.Update */ , e, n);
     hr("Data must be an object, but it was:", s, r);
     const i = [], o = ge.empty();
     Rt(r, ((t, r) => {
@@ -5037,7 +5037,7 @@ class rr extends jn {
 }
 
 /** Parse update data from a list of field/value arguments. */ function ir(t, e, n, r, s, i) {
-    const o = t.lt(1 /* UserDataSource.Update */ , e, n), u = [ lr(e, r, n) ], c = [ s ];
+    const o = t.ft(1 /* UserDataSource.Update */ , e, n), u = [ lr(e, r, n) ], c = [ s ];
     if (i.length % 2 != 0) throw new U(P, `Function ${e}() needs to be called with an even number of arguments that alternate between field names and values.`);
     for (let t = 0; t < i.length; t += 2) u.push(lr(e, i[t])), c.push(i[t + 1]);
     const a = [], h = ge.empty();
@@ -5068,7 +5068,7 @@ class rr extends jn {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function or(t, e, n, r = !1) {
-    return ur(n, t.lt(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , e));
+    return ur(n, t.ft(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , e));
 }
 
 /**
@@ -6631,26 +6631,26 @@ function ds(t, e) {
 class ys {
     constructor(t, e, n, r, s) {
         this.asyncQueue = t, this.datastore = e, this.options = n, this.updateFunction = r, 
-        this.deferred = s, this.wt = n.maxAttempts, this.yt = new mn(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
+        this.deferred = s, this.yt = n.maxAttempts, this.gt = new mn(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
-        this.wt -= 1, this.gt();
+        this.yt -= 1, this._t();
     }
-    gt() {
-        this.yt.K((async () => {
-            const t = new ms(this.datastore), e = this._t(t);
+    _t() {
+        this.gt.K((async () => {
+            const t = new ms(this.datastore), e = this.vt(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
                     this.deferred.resolve(e);
                 })).catch((t => {
-                    this.vt(t);
+                    this.bt(t);
                 }))));
             })).catch((t => {
-                this.vt(t);
+                this.bt(t);
             }));
         }));
     }
-    _t(t) {
+    vt(t) {
         try {
             const e = this.updateFunction(t);
             return !dt(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -6660,11 +6660,11 @@ class ys {
             return this.deferred.reject(t), null;
         }
     }
-    vt(t) {
-        this.wt > 0 && this.bt(t) ? (this.wt -= 1, this.asyncQueue.enqueueAndForget((() => (this.gt(), 
+    bt(t) {
+        this.yt > 0 && this.Et(t) ? (this.yt -= 1, this.asyncQueue.enqueueAndForget((() => (this._t(), 
         Promise.resolve())))) : this.deferred.reject(t);
     }
-    bt(t) {
+    Et(t) {
         if ("FirebaseError" === t.name) {
             // In transactions, the backend will fail outdated reads with FAILED_PRECONDITION and
             // non-matching document versions with ABORTED. These errors should be retried.
@@ -6835,39 +6835,39 @@ class ys {
  */ class vs {
     constructor() {
         // The last promise in the queue.
-        this.Et = Promise.resolve(), 
+        this.It = Promise.resolve(), 
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.It = [], 
+        this.Tt = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.Tt = !1, 
+        this.At = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this.At = [], 
+        this.Rt = [], 
         // visible for testing
-        this.Rt = null, 
+        this.Pt = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.Pt = !1, 
-        // Enabled during shutdown on Safari to prevent future access to IndexedDB.
         this.Vt = !1, 
+        // Enabled during shutdown on Safari to prevent future access to IndexedDB.
+        this.$t = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.$t = [], 
+        this.Nt = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.yt = new mn(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
+        this.gt = new mn(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
         // Visibility handler that triggers an immediate retry of all retryable
         // operations. Meant to speed up recovery when we regain file system access
         // after page comes into foreground.
-        this.Nt = () => {
+        this.Dt = () => {
             const t = gs();
-            t && y("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.yt.H();
+            t && y("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.gt.H();
         };
         const t = gs();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Nt);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Dt);
     }
     get isShuttingDown() {
-        return this.Tt;
+        return this.At;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -6877,38 +6877,38 @@ class ys {
         this.enqueue(t);
     }
     enqueueAndForgetEvenWhileRestricted(t) {
-        this.Dt(), 
+        this.Ft(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.Ft(t);
+        this.xt(t);
     }
     enterRestrictedMode(t) {
-        if (!this.Tt) {
-            this.Tt = !0, this.Vt = t || !1;
+        if (!this.At) {
+            this.At = !0, this.$t = t || !1;
             const e = gs();
-            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Nt);
+            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Dt);
         }
     }
     enqueue(t) {
-        if (this.Dt(), this.Tt) 
+        if (this.Ft(), this.At) 
         // Return a Promise which never resolves.
         return new Promise((() => {}));
         // Create a deferred Promise that we can return to the callee. This
         // allows us to return a "hanging Promise" only to the callee and still
         // advance the queue even when the operation is not run.
                 const e = new j;
-        return this.Ft((() => this.Tt && this.Vt ? Promise.resolve() : (t().then(e.resolve, e.reject), 
+        return this.xt((() => this.At && this.$t ? Promise.resolve() : (t().then(e.resolve, e.reject), 
         e.promise))).then((() => e.promise));
     }
     enqueueRetryable(t) {
-        this.enqueueAndForget((() => (this.It.push(t), this.xt())));
+        this.enqueueAndForget((() => (this.Tt.push(t), this.St())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async xt() {
-        if (0 !== this.It.length) {
+     */    async St() {
+        if (0 !== this.Tt.length) {
             try {
-                await this.It[0](), this.It.shift(), this.yt.reset();
+                await this.Tt[0](), this.Tt.shift(), this.gt.reset();
             } catch (t) {
                 if (!
                 /**
@@ -6952,7 +6952,7 @@ class ys {
  // Failure will be handled by AsyncQueue
                                 y("AsyncQueue", "Operation failed with retryable error: " + t);
             }
-            this.It.length > 0 && 
+            this.Tt.length > 0 && 
             // If there are additional operations, we re-schedule `retryNextOp()`.
             // This is necessary to run retryable operations that failed during
             // their initial attempt since we don't know whether they are already
@@ -6963,12 +6963,12 @@ class ys {
             // Since `backoffAndRun()` cancels an existing backoff and schedules a
             // new backoff on every call, there is only ever a single additional
             // operation in the queue.
-            this.yt.K((() => this.xt()));
+            this.gt.K((() => this.St()));
         }
     }
-    Ft(t) {
-        const e = this.Et.then((() => (this.Pt = !0, t().catch((t => {
-            this.Rt = t, this.Pt = !1;
+    xt(t) {
+        const e = this.It.then((() => (this.Vt = !0, t().catch((t => {
+            this.Pt = t, this.Vt = !1;
             const e = 
             /**
  * Chrome includes Error.message in Error.stack. Other browsers do not.
@@ -7009,38 +7009,38 @@ class ys {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw g("INTERNAL UNHANDLED ERROR: ", e), t;
-        })).then((t => (this.Pt = !1, t))))));
-        return this.Et = e, e;
+        })).then((t => (this.Vt = !1, t))))));
+        return this.It = e, e;
     }
     enqueueAfterDelay(t, e, n) {
-        this.Dt(), 
+        this.Ft(), 
         // Fast-forward delays for timerIds that have been overriden.
-        this.$t.indexOf(t) > -1 && (e = 0);
-        const r = _s.createAndSchedule(this, t, e, n, (t => this.St(t)));
-        return this.At.push(r), r;
+        this.Nt.indexOf(t) > -1 && (e = 0);
+        const r = _s.createAndSchedule(this, t, e, n, (t => this.qt(t)));
+        return this.Rt.push(r), r;
     }
-    Dt() {
-        this.Rt && b();
+    Ft() {
+        this.Pt && b();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async qt() {
+     */    async Ot() {
         // Operations in the queue prior to draining may have enqueued additional
         // operations. Keep draining the queue until the tail is no longer advanced,
         // which indicates that no more new operations were enqueued and that all
         // operations were executed.
         let t;
         do {
-            t = this.Et, await t;
-        } while (t !== this.Et);
+            t = this.It, await t;
+        } while (t !== this.It);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    Ot(t) {
-        for (const e of this.At) if (e.timerId === t) return !0;
+     */    kt(t) {
+        for (const e of this.Rt) if (e.timerId === t) return !0;
         return !1;
     }
     /**
@@ -7049,24 +7049,24 @@ class ys {
      * @param lastTimerId - Delayed operations up to and including this TimerId
      * will be drained. Pass TimerId.All to run all delayed operations.
      * @returns a Promise that resolves once all operations have been run.
-     */    kt(t) {
+     */    Ct(t) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.qt().then((() => {
+        return this.Ot().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
-            this.At.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
-            for (const e of this.At) if (e.skipDelay(), "all" /* TimerId.All */ !== t && e.timerId === t) break;
-            return this.qt();
+            this.Rt.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
+            for (const e of this.Rt) if (e.skipDelay(), "all" /* TimerId.All */ !== t && e.timerId === t) break;
+            return this.Ot();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    Ct(t) {
-        this.$t.push(t);
+     */    Mt(t) {
+        this.Nt.push(t);
     }
-    /** Called once a DelayedOperation is run or canceled. */    St(t) {
+    /** Called once a DelayedOperation is run or canceled. */    qt(t) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const e = this.At.indexOf(t);
-        this.At.splice(e, 1);
+        const e = this.Rt.indexOf(t);
+        this.Rt.splice(e, 1);
     }
 }
 
@@ -7173,7 +7173,7 @@ class bs {
     return n && s._setSettings(n), s;
 }), "PUBLIC").setMultipleInstances(!0)), 
 // RUNTIME_ENV and BUILD_TARGET are replaced by real values during the compilation
-registerVersion("firestore-lite", "3.12.0-20230511201449", ""), registerVersion("firestore-lite", "3.12.0-20230511201449", "esm2017");
+registerVersion("firestore-lite", "3.12.0", ""), registerVersion("firestore-lite", "3.12.0", "esm2017");
 
 export { $n as AggregateField, Nn as AggregateQuerySnapshot, Mn as Bytes, xn as CollectionReference, Dn as DocumentReference, pr as DocumentSnapshot, Ln as FieldPath, jn as FieldValue, Tn as Firestore, U as FirestoreError, Bn as GeoPoint, Fn as Query, Rr as QueryCompositeFilterConstraint, Er as QueryConstraint, yr as QueryDocumentSnapshot, kr as QueryEndAtConstraint, Tr as QueryFieldFilterConstraint, Dr as QueryLimitConstraint, $r as QueryOrderByConstraint, gr as QuerySnapshot, Sr as QueryStartAtConstraint, xt as Timestamp, bs as Transaction, fs as WriteBatch, Zr as addDoc, is as aggregateFieldEqual, os as aggregateQuerySnapshotEqual, Vr as and, hs as arrayRemove, as as arrayUnion, rs as average, Sn as collection, qn as collectionGroup, Pn as connectFirestoreEmulator, ss as count, Xr as deleteDoc, us as deleteField, On as doc, Un as documentId, Mr as endAt, Cr as endBefore, es as getAggregate, ts as getCount, Kr as getDoc, Yr as getDocs, Rn as getFirestore, ls as increment, An as initializeFirestore, Fr as limit, xr as limitToLast, Pr as or, Nr as orderBy, Ir as query, Cn as queryEqual, kn as refEqual, Es as runTransaction, cs as serverTimestamp, Hr as setDoc, p as setLogLevel, _r as snapshotEqual, Or as startAfter, qr as startAt, ns as sum, Vn as terminate, Jr as updateDoc, Ar as where, ws as writeBatch };
 //# sourceMappingURL=index.browser.esm2017.js.map