@firebase/firestore 3.4.8-canary.aa41fd662 → 3.4.8-canary.adb9aaa34

package/dist/firestore/lite/index.d.ts

@@ -17,6 +17,7 @@ export { FieldValue } from '../src/lite-api/field_value';
 export { increment, arrayRemove, arrayUnion, serverTimestamp, deleteField } from '../src/lite-api/field_value_impl';
 export { FirestoreDataConverter, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot, snapshotEqual } from '../src/lite-api/snapshot';
 export { WriteBatch, writeBatch } from '../src/lite-api/write_batch';
+export { TransactionOptions } from '../src/lite-api/transaction_options';
 export { Transaction, runTransaction } from '../src/lite-api/transaction';
 export { setLogLevel, LogLevelString as LogLevel } from '../src/util/log';
 export { Bytes } from '../src/lite-api/bytes';

package/dist/firestore/src/api/transaction.d.ts

@@ -19,6 +19,7 @@ import { DocumentReference } from '../lite-api/reference';
 import { Transaction as LiteTransaction } from '../lite-api/transaction';
 import { Firestore } from './database';
 import { DocumentSnapshot } from './snapshot';
+import { TransactionOptions } from './transaction_options';
 /**
  * A reference to a transaction.
  *
@@ -55,4 +56,4 @@ export declare class Transaction extends LiteTransaction {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;

package/dist/firestore/src/api/transaction_options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+export { TransactionOptions } from '../lite-api/transaction_options';

package/dist/firestore/src/api.d.ts

@@ -22,6 +22,7 @@ export { DocumentChange, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot,
 export { DocumentReference, CollectionReference, Query, doc, collection, collectionGroup, SetOptions, DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, refEqual, queryEqual } from './api/reference';
 export { endAt, endBefore, startAt, startAfter, limit, limitToLast, where, orderBy, query, QueryConstraint, QueryConstraintType, OrderByDirection, WhereFilterOp } from './api/filter';
 export { Unsubscribe, SnapshotListenOptions } from './api/reference_impl';
+export { TransactionOptions } from './api/transaction_options';
 export { runTransaction, Transaction } from './api/transaction';
 export { getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, onSnapshot, onSnapshotsInSync, setDoc, updateDoc, deleteDoc, addDoc, executeWrite } from './api/reference_impl';
 export { FieldValue } from './api/field_value';

package/dist/firestore/src/core/firestore_client.d.ts

@@ -30,6 +30,7 @@ import { EventManager, ListenOptions, Observer } from './event_manager';
 import { Query } from './query';
 import { SyncEngine } from './sync_engine';
 import { Transaction } from './transaction';
+import { TransactionOptions } from './transaction_options';
 import { ViewSnapshot } from './view_snapshot';
 export declare const MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
 /**
@@ -113,6 +114,6 @@ export declare function firestoreClientAddSnapshotsInSyncListener(client: Firest
  * been committed. For this reason, it is required that all reads are
  * performed before any writes. Transactions must be performed while online.
  */
-export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>, options: TransactionOptions): Promise<T>;
 export declare function firestoreClientLoadBundle(client: FirestoreClient, databaseId: DatabaseId, data: ReadableStream<Uint8Array> | ArrayBuffer | string, resultTask: LoadBundleTask): void;
 export declare function firestoreClientGetNamedQuery(client: FirestoreClient, queryName: string): Promise<NamedQuery | undefined>;

package/dist/firestore/src/core/target.d.ts

@@ -72,16 +72,16 @@ export declare function targetGetArrayValues(target: Target, fieldIndex: FieldIn
 export declare function targetGetNotInValues(target: Target, fieldIndex: FieldIndex): ProtoValue[] | null;
 /**
  * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
  * exists.
  */
-export declare function targetGetLowerBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+export declare function targetGetLowerBound(target: Target, fieldIndex: FieldIndex): Bound;
 /**
  * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
  * upper bound exists.
  */
-export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound;
 /** Returns the number of segments of a perfect index for this target. */
 export declare function targetGetSegmentCount(target: Target): number;
 export declare abstract class Filter {

package/dist/firestore/src/core/transaction_options.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+export declare const DEFAULT_TRANSACTION_OPTIONS: TransactionOptions;
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts: number;
+}
+export declare function validateTransactionOptions(options: TransactionOptions): void;

package/dist/firestore/src/core/transaction_runner.d.ts

@@ -18,7 +18,7 @@ import { Datastore } from '../remote/datastore';
 import { AsyncQueue } from '../util/async_queue';
 import { Deferred } from '../util/promise';
 import { Transaction } from './transaction';
-export declare const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
+import { TransactionOptions } from './transaction_options';
 /**
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
@@ -26,11 +26,12 @@ export declare const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
 export declare class TransactionRunner<T> {
     private readonly asyncQueue;
     private readonly datastore;
+    private readonly options;
     private readonly updateFunction;
     private readonly deferred;
     private attemptsRemaining;
     private backoff;
-    constructor(asyncQueue: AsyncQueue, datastore: Datastore, updateFunction: (transaction: Transaction) => Promise<T>, deferred: Deferred<T>);
+    constructor(asyncQueue: AsyncQueue, datastore: Datastore, options: TransactionOptions, updateFunction: (transaction: Transaction) => Promise<T>, deferred: Deferred<T>);
     /** Runs the transaction and sets the result on deferred. */
     run(): void;
     private runWithBackOff;

package/dist/firestore/src/lite-api/transaction.d.ts

@@ -19,6 +19,7 @@ import { Firestore } from './database';
 import { FieldPath } from './field_path';
 import { DocumentReference, PartialWithFieldValue, SetOptions, UpdateData, WithFieldValue } from './reference';
 import { DocumentSnapshot } from './snapshot';
+import { TransactionOptions } from './transaction_options';
 /**
  * A reference to a transaction.
  *
@@ -116,4 +117,4 @@ export declare class Transaction {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;

package/dist/firestore/src/lite-api/transaction_options.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts?: number;
+}

package/dist/firestore/src/local/indexeddb_index_manager.d.ts

@@ -70,11 +70,6 @@ export declare class IndexedDbIndexManager implements IndexManager {
     private generateLowerBound;
     /** Generates the upper bound for `arrayValue` and `directionalValue`. */
     private generateUpperBound;
-    /**
-     * Generates an empty bound that scopes the index scan to the current index
-     * and user.
-     */
-    private generateEmptyBound;
     private getFieldIndex;
     getIndexType(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexType>;
     /**

package/dist/firestore/src/model/values.d.ts

@@ -81,5 +81,17 @@ export declare function isMaxValue(value: Value): boolean;
 export declare function valuesGetLowerBound(value: Value): Value;
 /** Returns the largest value for the given value type (exclusive). */
 export declare function valuesGetUpperBound(value: Value): Value;
-export declare function valuesMax(left: Value | undefined, right: Value | undefined): Value | undefined;
-export declare function valuesMin(left: Value | undefined, right: Value | undefined): Value | undefined;
+export declare function lowerBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;
+export declare function upperBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;

package/dist/index.d.ts

@@ -1441,7 +1441,7 @@ export declare function refEqual<T>(left: DocumentReference<T> | CollectionRefer
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
  * include a server-generated timestamp in the written data.
@@ -1841,6 +1841,29 @@ within the document.
      */
     delete(documentRef: DocumentReference<unknown>): this;
 }
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts?: number;
+}
 /**
  * Given a union type `U = T1 | T2 | ...`, returns an intersected type
  * `(T1 & T2 & ...)`.