@firebase/firestore 3.4.13 → 3.4.14-canary.04dcdbb0f

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.13";
+const version$1 = "3.4.14-canary.04dcdbb0f";
 
 /**
  * @license
@@ -86,7 +86,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 = "9.9.1";
+const version = "9.9.3-canary.04dcdbb0f";
 
 /**
  * @license
@@ -641,19 +641,41 @@ class FirebaseAuthCredentialsProvider {
  * safer to keep the implementation as-is.
  */
 class FirstPartyToken {
-    constructor(gapi, sessionIndex, iamToken) {
+    constructor(gapi, sessionIndex, iamToken, authTokenFactory) {
+        this.gapi = gapi;
+        this.sessionIndex = sessionIndex;
+        this.iamToken = iamToken;
+        this.authTokenFactory = authTokenFactory;
         this.type = 'FirstParty';
         this.user = User.FIRST_PARTY;
-        this.headers = new Map();
-        this.headers.set('X-Goog-AuthUser', sessionIndex);
-        const authHeader = gapi['auth']['getAuthHeaderValueForFirstParty']([]);
-        if (authHeader) {
-            this.headers.set('Authorization', authHeader);
+        this._headers = new Map();
+    }
+    /** Gets an authorization token, using a provided factory function, or falling back to First Party GAPI. */
+    getAuthToken() {
+        if (this.authTokenFactory) {
+            return this.authTokenFactory();
         }
-        if (iamToken) {
-            this.headers.set('X-Goog-Iam-Authorization-Token', iamToken);
+        else {
+            // Make sure this really is a Gapi client.
+            hardAssert(!!(typeof this.gapi === 'object' &&
+                this.gapi !== null &&
+                this.gapi['auth'] &&
+                this.gapi['auth']['getAuthHeaderValueForFirstParty']));
+            return this.gapi['auth']['getAuthHeaderValueForFirstParty']([]);
         }
     }
+    get headers() {
+        this._headers.set('X-Goog-AuthUser', this.sessionIndex);
+        // Use array notation to prevent minification
+        const authHeaderTokenValue = this.getAuthToken();
+        if (authHeaderTokenValue) {
+            this._headers.set('Authorization', authHeaderTokenValue);
+        }
+        if (this.iamToken) {
+            this._headers.set('X-Goog-Iam-Authorization-Token', this.iamToken);
+        }
+        return this._headers;
+    }
 }
 /*
  * Provides user credentials required for the Firestore JavaScript SDK
@@ -661,13 +683,14 @@ class FirstPartyToken {
  * to applications hosted by Google.
  */
 class FirstPartyAuthCredentialsProvider {
-    constructor(gapi, sessionIndex, iamToken) {
+    constructor(gapi, sessionIndex, iamToken, authTokenFactory) {
         this.gapi = gapi;
         this.sessionIndex = sessionIndex;
         this.iamToken = iamToken;
+        this.authTokenFactory = authTokenFactory;
     }
     getToken() {
-        return Promise.resolve(new FirstPartyToken(this.gapi, this.sessionIndex, this.iamToken));
+        return Promise.resolve(new FirstPartyToken(this.gapi, this.sessionIndex, this.iamToken, this.authTokenFactory));
     }
     start(asyncQueue, changeListener) {
         // Fire with initial uid.
@@ -778,12 +801,7 @@ function makeAuthCredentialsProvider(credentials) {
     switch (credentials['type']) {
         case 'gapi':
             const client = credentials['client'];
-            // Make sure this really is a Gapi client.
-            hardAssert(!!(typeof client === 'object' &&
-                client !== null &&
-                client['auth'] &&
-                client['auth']['getAuthHeaderValueForFirstParty']));
-            return new FirstPartyAuthCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null);
+            return new FirstPartyAuthCredentialsProvider(client, credentials['sessionIndex'] || '0', credentials['iamToken'] || null, credentials['authTokenFactory'] || null);
         case 'provider':
             return credentials['client'];
         default:
@@ -1523,6 +1541,23 @@ function fieldIndexGetKeyOrder(fieldIndex) {
         ? 0 /* ASCENDING */
         : directionalSegments[directionalSegments.length - 1].kind;
 }
+/**
+ * Compares indexes by collection group and segments. Ignores update time and
+ * index ID.
+ */
+function fieldIndexSemanticComparator(left, right) {
+    let cmp = primitiveComparator(left.collectionGroup, right.collectionGroup);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    for (let i = 0; i < Math.min(left.fields.length, right.fields.length); ++i) {
+        cmp = indexSegmentComparator(left.fields[i], right.fields[i]);
+        if (cmp !== 0) {
+            return cmp;
+        }
+    }
+    return primitiveComparator(left.fields.length, right.fields.length);
+}
 /** Returns a debug representation of the field index */
 function fieldIndexToString(fieldIndex) {
     return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
@@ -1538,6 +1573,13 @@ class IndexSegment {
         this.kind = kind;
     }
 }
+function indexSegmentComparator(left, right) {
+    const cmp = FieldPath$1.comparator(left.fieldPath, right.fieldPath);
+    if (cmp !== 0) {
+        return cmp;
+    }
+    return primitiveComparator(left.kind, right.kind);
+}
 /**
  * Stores the "high water mark" that indicates how updated the Index is for the
  * current user.
@@ -1624,31 +1666,6 @@ function indexOffsetComparator(left, right) {
     }
     return primitiveComparator(left.largestBatchId, right.largestBatchId);
 }
-/**
- * Schema Version for the Web client:
- * 1.  Initial version including Mutation Queue, Query Cache, and Remote
- *     Document Cache
- * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
- *     longer required because migration 3 unconditionally clears it.
- * 3.  Dropped and re-created Query Cache to deal with cache corruption related
- *     to limbo resolution. Addresses
- *     https://github.com/firebase/firebase-ios-sdk/issues/1548
- * 4.  Multi-Tab Support.
- * 5.  Removal of held write acks.
- * 6.  Create document global for tracking document cache size.
- * 7.  Ensure every cached document has a sentinel row with a sequence number.
- * 8.  Add collection-parent index for Collection Group queries.
- * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
- *     an auto-incrementing ID. This is required for Index-Free queries.
- * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
- * 11. Add bundles and named_queries for bundle support.
- * 12. Add document overlays.
- * 13. Rewrite the keys of the remote document cache to allow for efficient
- *     document lookup via `getAll()`.
- * 14. Add overlays.
- * 15. Add indexing support.
- */
-const SCHEMA_VERSION = 14;
 
 /**
  * @license
@@ -2608,6 +2625,8 @@ function checkForAndReportiOSError(error) {
 }
 
 const LOG_TAG$h = 'IndexBackiller';
+/** How long we wait to try running index backfill after SDK initialization. */
+const INITIAL_BACKFILL_DELAY_MS = 15;
 /** Minimum amount of time between backfill checks, after the first one. */
 const REGULAR_BACKFILL_DELAY_MS = 1;
 /** The maximum number of documents to process each time backfill() is called. */
@@ -2620,6 +2639,7 @@ class IndexBackfillerScheduler {
         this.task = null;
     }
     start() {
+        this.schedule(INITIAL_BACKFILL_DELAY_MS);
     }
     stop() {
         if (this.task) {
@@ -4348,6 +4368,12 @@ class DatabaseId {
             other.projectId === this.projectId &&
             other.database === this.database);
     }
+}
+function databaseIdFromApp(app, database) {
+    if (!Object.prototype.hasOwnProperty.apply(app.options, ['projectId'])) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, '"projectId" not provided in firebase.initializeApp.');
+    }
+    return new DatabaseId(app.options.projectId, database);
 }
 
 /**
@@ -12735,6 +12761,48 @@ function dbKeyComparator(l, r) {
     return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }
 
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+/**
+ * Schema Version for the Web client:
+ * 1.  Initial version including Mutation Queue, Query Cache, and Remote
+ *     Document Cache
+ * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
+ *     longer required because migration 3 unconditionally clears it.
+ * 3.  Dropped and re-created Query Cache to deal with cache corruption related
+ *     to limbo resolution. Addresses
+ *     https://github.com/firebase/firebase-ios-sdk/issues/1548
+ * 4.  Multi-Tab Support.
+ * 5.  Removal of held write acks.
+ * 6.  Create document global for tracking document cache size.
+ * 7.  Ensure every cached document has a sentinel row with a sequence number.
+ * 8.  Add collection-parent index for Collection Group queries.
+ * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
+ *     an auto-incrementing ID. This is required for Index-Free queries.
+ * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
+ * 11. Add bundles and named_queries for bundle support.
+ * 12. Add document overlays.
+ * 13. Rewrite the keys of the remote document cache to allow for efficient
+ *     document lookup via `getAll()`.
+ * 14. Add overlays.
+ * 15. Add indexing support.
+ */
+const SCHEMA_VERSION = 15;
+
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -15273,6 +15341,73 @@ async function indexedDbClearPersistence(persistenceKey) {
     await SimpleDb.delete(dbName);
 }
 
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+/**
+ * Compares two array for equality using comparator. The method computes the
+ * intersection and invokes `onAdd` for every element that is in `after` but not
+ * `before`. `onRemove` is invoked for every element in `before` but missing
+ * from `after`.
+ *
+ * The method creates a copy of both `before` and `after` and runs in O(n log
+ * n), where n is the size of the two lists.
+ *
+ * @param before - The elements that exist in the original array.
+ * @param after - The elements to diff against the original array.
+ * @param comparator - The comparator for the elements in before and after.
+ * @param onAdd - A function to invoke for every element that is part of `
+ * after` but not `before`.
+ * @param onRemove - A function to invoke for every element that is part of
+ * `before` but not `after`.
+ */
+function diffArrays(before, after, comparator, onAdd, onRemove) {
+    before = [...before];
+    after = [...after];
+    before.sort(comparator);
+    after.sort(comparator);
+    const bLen = before.length;
+    const aLen = after.length;
+    let a = 0;
+    let b = 0;
+    while (a < aLen && b < bLen) {
+        const cmp = comparator(before[b], after[a]);
+        if (cmp < 0) {
+            // The element was removed if the next element in our ordered
+            // walkthrough is only in `before`.
+            onRemove(before[b++]);
+        }
+        else if (cmp > 0) {
+            // The element was added if the next element in our ordered walkthrough
+            // is only in `after`.
+            onAdd(after[a++]);
+        }
+        else {
+            a++;
+            b++;
+        }
+    }
+    while (a < aLen) {
+        onAdd(after[a++]);
+    }
+    while (b < bLen) {
+        onRemove(before[b++]);
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -16122,6 +16257,19 @@ async function localStoreSaveNamedQuery(localStore, query, documents = documentK
             .next(() => localStoreImpl.targetCache.addMatchingKeys(transaction, documents, allocated.targetId))
             .next(() => localStoreImpl.bundleCache.saveNamedQuery(transaction, query));
     });
+}
+async function localStoreConfigureFieldIndexes(localStore, newFieldIndexes) {
+    const localStoreImpl = debugCast(localStore);
+    const indexManager = localStoreImpl.indexManager;
+    const promises = [];
+    return localStoreImpl.persistence.runTransaction('Configure indexes', 'readwrite', transaction => indexManager
+        .getFieldIndexes(transaction)
+        .next(oldFieldIndexes => diffArrays(oldFieldIndexes, newFieldIndexes, fieldIndexSemanticComparator, fieldIndex => {
+        promises.push(indexManager.addFieldIndex(transaction, fieldIndex));
+    }, fieldIndex => {
+        promises.push(indexManager.deleteFieldIndex(transaction, fieldIndex));
+    }))
+        .next(() => PersistencePromise.waitFor(promises)));
 }
 
 /**
@@ -16201,9 +16349,56 @@ class QueryEngine {
      * persisted index values. Returns `null` if an index is not available.
      */
     performQueryUsingIndex(transaction, query) {
-        {
+        if (queryMatchesAllDocuments(query)) {
+            // Queries that match all documents don't benefit from using
+            // key-based lookups. It is more efficient to scan all documents in a
+            // collection, rather than to perform individual lookups.
             return PersistencePromise.resolve(null);
         }
+        let target = queryToTarget(query);
+        return this.indexManager
+            .getIndexType(transaction, target)
+            .next(indexType => {
+            if (indexType === 0 /* NONE */) {
+                // The target cannot be served from any index.
+                return null;
+            }
+            if (query.limit !== null && indexType === 1 /* PARTIAL */) {
+                // We cannot apply a limit for targets that are served using a partial
+                // index. If a partial index will be used to serve the target, the
+                // query may return a superset of documents that match the target
+                // (e.g. if the index doesn't include all the target's filters), or
+                // may return the correct set of documents in the wrong order (e.g. if
+                // the index doesn't include a segment for one of the orderBys).
+                // Therefore, a limit should not be applied in such cases.
+                query = queryWithLimit(query, null, "F" /* First */);
+                target = queryToTarget(query);
+            }
+            return this.indexManager
+                .getDocumentsMatchingTarget(transaction, target)
+                .next(keys => {
+                const sortedKeys = documentKeySet(...keys);
+                return this.localDocumentsView
+                    .getDocuments(transaction, sortedKeys)
+                    .next(indexedDocuments => {
+                    return this.indexManager
+                        .getMinOffset(transaction, target)
+                        .next(offset => {
+                        const previousResults = this.applyQuery(query, indexedDocuments);
+                        if (this.needsRefill(query, previousResults, sortedKeys, offset.readTime)) {
+                            // A limit query whose boundaries change due to local
+                            // edits can be re-run against the cache by excluding the
+                            // limit. This ensures that all documents that match the
+                            // query's filters are included in the result set. The SDK
+                            // can then apply the limit once all local edits are
+                            // incorporated.
+                            return this.performQueryUsingIndex(transaction, queryWithLimit(query, null, "F" /* First */));
+                        }
+                        return this.appendRemainingResults(transaction, previousResults, query, offset);
+                    });
+                });
+            });
+        });
     }
     /**
      * Performs a query based on the target's persisted query mapping. Returns
@@ -24298,7 +24493,7 @@ class AsyncObserver {
             this.scheduleEvent(this.observer.error, error);
         }
         else {
-            console.error('Uncaught Error in snapshot listener:', error);
+            logError('Uncaught Error in snapshot listener:', error);
         }
     }
     mute() {
@@ -24594,7 +24789,7 @@ class Transaction$2 {
             docVersion = doc.version;
         }
         else if (doc.isNoDocument()) {
-            // For deleted docs, we must use baseVersion 0 when we overwrite them.
+            // Represent a deleted doc using SnapshotVersion.min().
             docVersion = SnapshotVersion.min();
         }
         else {
@@ -24618,7 +24813,12 @@ class Transaction$2 {
     precondition(key) {
         const version = this.readVersions.get(key.toString());
         if (!this.writtenDocs.has(key.toString()) && version) {
-            return Precondition.updateTime(version);
+            if (version.isEqual(SnapshotVersion.min())) {
+                return Precondition.exists(false);
+            }
+            else {
+                return Precondition.updateTime(version);
+            }
         }
         else {
             return Precondition.none();
@@ -25313,9 +25513,11 @@ class FirestoreSettingsImpl {
  */
 class Firestore$1 {
     /** @hideconstructor */
-    constructor(databaseIdOrApp, _authCredentials, _appCheckCredentials) {
+    constructor(_authCredentials, _appCheckCredentials, _databaseId, _app) {
         this._authCredentials = _authCredentials;
         this._appCheckCredentials = _appCheckCredentials;
+        this._databaseId = _databaseId;
+        this._app = _app;
         /**
          * Whether it's a Firestore or Firestore Lite instance.
          */
@@ -25323,13 +25525,6 @@ class Firestore$1 {
         this._persistenceKey = '(lite)';
         this._settings = new FirestoreSettingsImpl({});
         this._settingsFrozen = false;
-        if (databaseIdOrApp instanceof DatabaseId) {
-            this._databaseId = databaseIdOrApp;
-        }
-        else {
-            this._app = databaseIdOrApp;
-            this._databaseId = databaseIdFromApp(databaseIdOrApp);
-        }
     }
     /**
      * The {@link @firebase/app#FirebaseApp} associated with this `Firestore` service
@@ -25392,12 +25587,6 @@ class Firestore$1 {
         return Promise.resolve();
     }
 }
-function databaseIdFromApp(app) {
-    if (!Object.prototype.hasOwnProperty.apply(app.options, ['projectId'])) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, '"projectId" not provided in firebase.initializeApp.');
-    }
-    return new DatabaseId(app.options.projectId);
-}
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
  *
@@ -26066,15 +26255,14 @@ const CACHE_SIZE_UNLIMITED = LRU_COLLECTION_DISABLED;
  */
 class Firestore extends Firestore$1 {
     /** @hideconstructor */
-    constructor(databaseIdOrApp, authCredentialsProvider, appCheckCredentialsProvider) {
-        super(databaseIdOrApp, authCredentialsProvider, appCheckCredentialsProvider);
+    constructor(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app) {
+        super(authCredentialsProvider, appCheckCredentialsProvider, databaseId, app);
         /**
          * Whether it's a {@link Firestore} or Firestore Lite instance.
          */
         this.type = 'firestore';
         this._queue = newAsyncQueue();
-        this._persistenceKey =
-            'name' in databaseIdOrApp ? databaseIdOrApp.name : '[DEFAULT]';
+        this._persistenceKey = (app === null || app === void 0 ? void 0 : app.name) || '[DEFAULT]';
     }
     _terminate() {
         if (!this._firestoreClient) {
@@ -26094,13 +26282,19 @@ class Firestore extends Firestore$1 {
  * @param app - The {@link @firebase/app#FirebaseApp} with which the {@link Firestore} instance will
  * be associated.
  * @param settings - A settings object to configure the {@link Firestore} instance.
+ * @param databaseId - The name of database.
  * @returns A newly initialized {@link Firestore} instance.
  */
-function initializeFirestore(app$1, settings) {
+function initializeFirestore(app$1, settings, databaseId) {
+    if (!databaseId) {
+        databaseId = DEFAULT_DATABASE_NAME;
+    }
     const provider = app._getProvider(app$1, 'firestore');
-    if (provider.isInitialized()) {
-        const existingInstance = provider.getImmediate();
-        const initialSettings = provider.getOptions();
+    if (provider.isInitialized(databaseId)) {
+        const existingInstance = provider.getImmediate({
+            identifier: databaseId
+        });
+        const initialSettings = provider.getOptions(databaseId);
         if (util$1.deepEqual(initialSettings, settings)) {
             return existingInstance;
         }
@@ -26116,19 +26310,19 @@ function initializeFirestore(app$1, settings) {
         settings.cacheSizeBytes < LRU_MINIMUM_CACHE_SIZE_BYTES) {
         throw new FirestoreError(Code.INVALID_ARGUMENT, `cacheSizeBytes must be at least ${LRU_MINIMUM_CACHE_SIZE_BYTES}`);
     }
-    return provider.initialize({ options: settings });
+    return provider.initialize({
+        options: settings,
+        instanceIdentifier: databaseId
+    });
 }
-/**
- * Returns the existing {@link Firestore} instance that is associated with the
- * provided {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
- * instance with default settings.
- *
- * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned {@link Firestore}
- * instance is associated with.
- * @returns The {@link Firestore} instance of the provided app.
- */
-function getFirestore(app$1 = app.getApp()) {
-    return app._getProvider(app$1, 'firestore').getImmediate();
+function getFirestore(appOrDatabaseId, optionalDatabaseId) {
+    const app$1 = typeof appOrDatabaseId === 'object' ? appOrDatabaseId : app.getApp();
+    const databaseId = typeof appOrDatabaseId === 'string'
+        ? appOrDatabaseId
+        : optionalDatabaseId || DEFAULT_DATABASE_NAME;
+    return app._getProvider(app$1, 'firestore').getImmediate({
+        identifier: databaseId
+    });
 }
 /**
  * @internal
@@ -26229,7 +26423,7 @@ function setPersistenceProviders(client, onlineComponentProvider, offlineCompone
             if (!canFallbackFromIndexedDbError(error)) {
                 throw error;
             }
-            console.warn('Error enabling offline persistence. Falling back to ' +
+            logWarn('Error enabling offline persistence. Falling back to ' +
                 'persistence disabled: ' +
                 error);
             persistenceResult.reject(error);
@@ -26374,7 +26568,7 @@ function disableNetwork(firestore) {
  * terminated.
  */
 function terminate(firestore) {
-    app._removeServiceInstance(firestore.app, 'firestore');
+    app._removeServiceInstance(firestore.app, 'firestore', firestore._databaseId.database);
     return firestore._delete();
 }
 /**
@@ -26443,13 +26637,13 @@ function verifyNotInitialized(firestore) {
  */
 function registerFirestore(variant, useFetchStreams = true) {
     setSDKVersion(app.SDK_VERSION);
-    app._registerComponent(new component.Component('firestore', (container, { options: settings }) => {
+    app._registerComponent(new component.Component('firestore', (container, { instanceIdentifier: databaseId, options: settings }) => {
         const app = container.getProvider('app').getImmediate();
-        const firestoreInstance = new Firestore(app, new FirebaseAuthCredentialsProvider(container.getProvider('auth-internal')), new FirebaseAppCheckTokenProvider(container.getProvider('app-check-internal')));
+        const firestoreInstance = new Firestore(new FirebaseAuthCredentialsProvider(container.getProvider('auth-internal')), new FirebaseAppCheckTokenProvider(container.getProvider('app-check-internal')), databaseIdFromApp(app, databaseId), app);
         settings = Object.assign({ useFetchStreams }, settings);
         firestoreInstance._setSettings(settings);
         return firestoreInstance;
-    }, 'PUBLIC'));
+    }, 'PUBLIC').setMultipleInstances(true));
     app.registerVersion(name, version$1, variant);
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
     app.registerVersion(name, version$1, 'cjs2017');
@@ -29143,14 +29337,23 @@ function writeBatch(firestore) {
  * limitations under the License.
  */
 function setIndexConfiguration(firestore, jsonOrConfiguration) {
+    var _a;
     firestore = cast(firestore, Firestore);
-    ensureFirestoreConfigured(firestore);
+    const client = ensureFirestoreConfigured(firestore);
+    // PORTING NOTE: We don't return an error if the user has not enabled
+    // persistence since `enableIndexeddbPersistence()` can fail on the Web.
+    if (!((_a = client.offlineComponents) === null || _a === void 0 ? void 0 : _a.indexBackfillerScheduler)) {
+        logWarn('Cannot enable indexes when persistence is disabled');
+        return Promise.resolve();
+    }
+    const parsedIndexes = parseIndexes(jsonOrConfiguration);
+    return getLocalStore(client).then(localStore => localStoreConfigureFieldIndexes(localStore, parsedIndexes));
+}
+function parseIndexes(jsonOrConfiguration) {
     const indexConfiguration = typeof jsonOrConfiguration === 'string'
         ? tryParseJson(jsonOrConfiguration)
         : jsonOrConfiguration;
     const parsedIndexes = [];
-    // PORTING NOTE: We don't return an error if the user has not enabled
-    // persistence since `enableIndexeddbPersistence()` can fail on the Web.
     if (Array.isArray(indexConfiguration.indexes)) {
         for (const index of indexConfiguration.indexes) {
             const collectionGroup = tryGetString(index, 'collectionGroup');
@@ -29173,8 +29376,7 @@ function setIndexConfiguration(firestore, jsonOrConfiguration) {
             parsedIndexes.push(new FieldIndex(FieldIndex.UNKNOWN_ID, collectionGroup, segments, IndexState.empty()));
         }
     }
-    // TODO(indexing): Configure indexes
-    return Promise.resolve();
+    return parsedIndexes;
 }
 function tryParseJson(json) {
     var _a;
@@ -29182,7 +29384,7 @@ function tryParseJson(json) {
         return JSON.parse(json);
     }
     catch (e) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON:' + ((_a = e) === null || _a === void 0 ? void 0 : _a.message));
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON: ' + ((_a = e) === null || _a === void 0 ? void 0 : _a.message));
     }
 }
 function tryGetString(data, property) {
@@ -29239,7 +29441,6 @@ exports._cast = cast;
 exports._debugAssert = debugAssert;
 exports._isBase64Available = isBase64Available;
 exports._logWarn = logWarn;
-exports._setIndexConfiguration = setIndexConfiguration;
 exports._validateIsNotUsedTogether = validateIsNotUsedTogether;
 exports.addDoc = addDoc;
 exports.arrayRemove = arrayRemove;
@@ -29282,6 +29483,7 @@ exports.refEqual = refEqual;
 exports.runTransaction = runTransaction;
 exports.serverTimestamp = serverTimestamp;
 exports.setDoc = setDoc;
+exports.setIndexConfiguration = setIndexConfiguration;
 exports.setLogLevel = setLogLevel;
 exports.snapshotEqual = snapshotEqual;
 exports.startAfter = startAfter;