@dereekb/firebase 13.6.6 → 13.6.7

package/index.cjs.js

@@ -488,7 +488,7 @@ function _is_native_reflect_construct$9() {
     return COPY_USER_RELATED_DATA_ACCESSOR_FACTORY_FUNCTION();
 }
 
-function asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$l(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -502,22 +502,22 @@ function asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$k(fn) {
+function _async_to_generator$l(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$l(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$l(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$k(thisArg, body) {
+function _ts_generator$l(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -687,9 +687,9 @@ function _ts_generator$k(thisArg, body) {
  * @returns A function that updates the document with converted data
  */ function updateWithAccessorUpdateAndConverterFunction(accessor, converter) {
     return function(data, params) {
-        return _async_to_generator$k(function() {
+        return _async_to_generator$l(function() {
             var updateInput, updateData;
-            return _ts_generator$k(this, function(_state) {
+            return _ts_generator$l(this, function(_state) {
                 updateInput = util.filterUndefinedValues(data);
                 updateData = converter.toFirestore(updateInput, {
                     merge: true
@@ -732,7 +732,129 @@ function _ts_generator$k(thisArg, body) {
      */ FirestoreDocumentContextType["BATCH"] = "batch";
 })(exports.FirestoreDocumentContextType || (exports.FirestoreDocumentContextType = {}));
 
-function asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, key, arg) {
+/**
+ * Creates a {@link FirestoreCollectionDocumentCache} that delegates to the given
+ * collection cache with the key pre-bound.
+ *
+ * @param collectionCache - The parent collection cache
+ * @param key - The document path to bind
+ * @returns A document-scoped cache
+ *
+ * @example
+ * ```ts
+ * const docCache = firestoreCollectionDocumentCache(collectionCache, 'users/abc');
+ * docCache.set({ data: userData });
+ * const entry = docCache.get();
+ * ```
+ */ function firestoreCollectionDocumentCache(collectionCache, key) {
+    return {
+        get: function get(maxTtl) {
+            return collectionCache.get(key, maxTtl);
+        },
+        set: function set(entry) {
+            return collectionCache.set(key, entry);
+        },
+        invalidate: function invalidate() {
+            return collectionCache.invalidate(key);
+        }
+    };
+}
+/**
+ * Singleton noop {@link FirestoreCollectionDocumentCache} that discards all operations.
+ */ var NOOP_FIRESTORE_COLLECTION_DOCUMENT_CACHE = {
+    get: function get() {
+        return undefined;
+    },
+    set: function set() {},
+    invalidate: function invalidate() {}
+};
+/**
+ * Returns the singleton noop {@link FirestoreCollectionDocumentCache}.
+ */ function noopFirestoreCollectionDocumentCache() {
+    return NOOP_FIRESTORE_COLLECTION_DOCUMENT_CACHE;
+}
+// MARK: Noop
+/**
+ * Singleton noop {@link FirestoreCollectionCacheInstance} that discards all operations.
+ */ var NOOP_FIRESTORE_COLLECTION_CACHE_INSTANCE = {
+    get: function get() {
+        return undefined;
+    },
+    getOrFetch: function getOrFetch(_key, fetchFn) {
+        return fetchFn();
+    }
+};
+/**
+ * Singleton noop {@link FirestoreCollectionCache} that discards all operations.
+ *
+ * Used when no cache driver is configured so that `.cache` is always defined,
+ * avoiding optional checks throughout the codebase.
+ */ var NOOP_FIRESTORE_COLLECTION_CACHE = {
+    defaultTtl: 0,
+    get: function get() {
+        return undefined;
+    },
+    set: function set() {},
+    invalidate: function invalidate() {},
+    clear: function clear() {},
+    instance: function instance() {
+        return NOOP_FIRESTORE_COLLECTION_CACHE_INSTANCE;
+    },
+    destroy: function destroy() {}
+};
+/**
+ * Returns the singleton noop {@link FirestoreCollectionCache} that discards all operations.
+ *
+ * Used when no cache driver is configured so that `.cache` is always defined.
+ *
+ * @example
+ * ```ts
+ * const cache = noopFirestoreCollectionCache();
+ * cache.get('path/to/doc'); // always returns undefined
+ * cache.set('path/to/doc', { data }); // no-op
+ * ```
+ */ function noopFirestoreCollectionCache() {
+    return NOOP_FIRESTORE_COLLECTION_CACHE;
+}
+/**
+ * Singleton noop {@link FirestoreContextCache} that always returns noop collection caches.
+ *
+ * Used when no cache factory is configured so that `FirestoreContext.cache` is always defined.
+ */ var NOOP_FIRESTORE_CONTEXT_CACHE = {
+    cacheForCollection: function cacheForCollection() {
+        return noopFirestoreCollectionCache();
+    },
+    events$: rxjs$1.EMPTY,
+    disabledTypes: new Set(),
+    isEnabled: function isEnabled() {
+        return false;
+    },
+    setEnabled: function setEnabled() {},
+    clearAll: function clearAll() {},
+    isEnabledForType: function isEnabledForType() {
+        return false;
+    },
+    setEnabledForType: function setEnabledForType() {},
+    clearForType: function clearForType() {},
+    destroy: function destroy() {}
+};
+/**
+ * Returns the singleton noop {@link FirestoreContextCache}.
+ *
+ * Used when no cache factory is configured so that `FirestoreContext.cache` is always defined,
+ * avoiding null checks throughout the codebase.
+ *
+ * @example
+ * ```ts
+ * const cache = noopFirestoreContextCache();
+ * cache.cacheForCollection('user', { defaultTtl: 0 }); // returns noop collection cache
+ * cache.isEnabled(); // false
+ * ```
+ */ function noopFirestoreContextCache() {
+    return NOOP_FIRESTORE_CONTEXT_CACHE;
+}
+
+function asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -746,22 +868,22 @@ function asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$j(fn) {
+function _async_to_generator$k(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$k(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$j(thisArg, body) {
+function _ts_generator$k(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -874,9 +996,9 @@ function _ts_generator$j(thisArg, body) {
  * @see https://cloud.google.com/firestore/docs/samples/firestore-data-set-numeric-increment
  */ function incrementUpdateWithAccessorFunction(accessor) {
     return function(data) {
-        return _async_to_generator$j(function() {
+        return _async_to_generator$k(function() {
             var updateData;
-            return _ts_generator$j(this, function(_state) {
+            return _ts_generator$k(this, function(_state) {
                 updateData = util.filterFalsyAndEmptyValues(data);
                 // Only update
                 if (!util.objectHasNoKeys(updateData)) {
@@ -893,7 +1015,7 @@ function _ts_generator$j(thisArg, body) {
     };
 }
 
-function asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -907,22 +1029,22 @@ function asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$i(fn) {
+function _async_to_generator$j(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$j(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$i(thisArg, body) {
+function _ts_generator$j(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1034,9 +1156,9 @@ function _ts_generator$i(thisArg, body) {
  * @see https://firebase.google.com/docs/firestore/manage-data/add-data#update_elements_in_an_array
  */ function arrayUpdateWithAccessorFunction(accessor) {
     return function(data) {
-        return _async_to_generator$i(function() {
+        return _async_to_generator$j(function() {
             var updateData;
-            return _ts_generator$i(this, function(_state) {
+            return _ts_generator$j(this, function(_state) {
                 updateData = util.filterFalsyAndEmptyValues(data);
                 // Only update
                 if (!util.objectHasNoKeys(updateData)) {
@@ -1158,6 +1280,7 @@ function _is_native_reflect_construct$8() {
         _class_call_check$h(this, AbstractFirestoreDocument);
         _define_property$u(this, "_accessor", void 0);
         _define_property$u(this, "_documentAccessor", void 0);
+        _define_property$u(this, "_cache", void 0);
         _define_property$u(this, "stream$", rxjs.lazyFrom(function() {
             return _this._accessor.stream();
         }));
@@ -1166,6 +1289,7 @@ function _is_native_reflect_construct$8() {
         }));
         this._accessor = accessor;
         this._documentAccessor = documentAccessor;
+        this._cache = documentAccessor.cacheForDocument(accessor.documentRef);
     }
     _create_class$a(AbstractFirestoreDocument, [
         {
@@ -1174,6 +1298,12 @@ function _is_native_reflect_construct$8() {
                 return this._accessor;
             }
         },
+        {
+            key: "cache",
+            get: function get() {
+                return this._cache;
+            }
+        },
         {
             key: "documentAccessor",
             get: function get() {
@@ -1226,41 +1356,69 @@ function _is_native_reflect_construct$8() {
             /**
      * Retrieves a DocumentSnapshot of the document as an Observable. Streams based on the input mode.
      *
+     * Passively populates the cache with each emitted snapshot.
+     *
      * @param mode - The stream mode controlling how the Observable emits snapshot updates
      * @returns An Observable that emits DocumentSnapshot values based on the given mode
      */ key: "snapshotStream",
             value: function snapshotStream(mode) {
-                return snapshotStreamForAccessor(this.accessor, mode);
+                var _this = this;
+                return snapshotStreamForAccessor(this.accessor, mode).pipe(rxjs$1.tap(function(snap) {
+                    var data = snap.data();
+                    if (data != null) {
+                        _this._cache.set({
+                            data: data
+                        });
+                    }
+                }));
             }
         },
         {
             /**
      * Retrieves the data of the DocumentSnapshot of the document as an Observable. Streams based on the input mode.
      *
+     * Passively populates the cache via {@link snapshotStream}.
+     *
      * @param mode - The stream mode controlling how the Observable emits snapshot data updates
      * @param options - Optional SnapshotOptions for reading the document data
      * @returns An Observable that emits the document data or undefined based on the given mode
      */ key: "snapshotDataStream",
             value: function snapshotDataStream(mode, options) {
-                return snapshotStreamDataForAccessor(this.accessor, mode, options);
+                return this.snapshotStream(mode).pipe(rxjs$1.map(function(snap) {
+                    return snap.data(options);
+                }));
             }
         },
         {
             /**
-     * Retrieves a DocumentSnapshot of the document.
+     * Retrieves a DocumentSnapshot of the document from Firestore.
      *
-     * @returns
+     * Passively populates the cache with the fetched snapshot.
+     *
+     * @returns A Promise resolving to the document snapshot
      */ key: "snapshot",
             value: function snapshot() {
-                return this.accessor.get();
+                var _this = this;
+                return this.accessor.get().then(function(snap) {
+                    var data = snap.data();
+                    if (data != null) {
+                        _this._cache.set({
+                            data: data
+                        });
+                    }
+                    return snap;
+                });
             }
         },
         {
             /**
-     * Retrieves the data of the DocumentSnapshot of the document.
+     * Retrieves the data of the document, checking the cache first.
      *
-     * @param options
-     * @returns
+     * If a fresh cache entry exists, returns it without hitting Firestore.
+     * Otherwise falls through to {@link snapshot} which populates the cache.
+     *
+     * @param options - Optional SnapshotOptions for reading the document data
+     * @returns A Promise resolving to the document data, or undefined if the document does not exist
      */ key: "snapshotData",
             value: function snapshotData(options) {
                 return this.snapshot().then(function(x) {
@@ -1283,49 +1441,74 @@ function _is_native_reflect_construct$8() {
             /**
      * Creates the document if it does not exist, using the accessor's create functionality.
      *
-     * @param data
-     * @returns
+     * Populates the cache with the written data after a successful create.
+     *
+     * @param data - The document data to create
+     * @returns A Promise that resolves when the create completes
      */ key: "create",
             value: function create(data) {
-                return this.accessor.create(data);
+                var _this = this;
+                return this.accessor.create(data).then(function(result) {
+                    _this._cache.set({
+                        data: data
+                    });
+                    return result;
+                });
             }
         },
         {
             /**
-     * Updates the document using the accessor's update functionalty if the document exists. This differs from Firestore's default
+     * Updates the document using the accessor's update functionality if the document exists. This differs from Firestore's default
      * update implementation which does not use the configured converter. This update function will, allowing the use of
      * snapshotConverterFunctions().
      *
-     * Throws an exception when it does not exist.
+     * Invalidates the cache entry since partial updates don't provide the full document.
+     * Throws an exception when the document does not exist.
      *
      * @param data - Partial document data to update
      * @param params - Optional update parameters
      * @returns A Promise that resolves when the update completes
      */ key: "update",
             value: function update(data, params) {
-                return updateWithAccessorUpdateAndConverterFunction(this.accessor, this.converter)(data, params);
+                var _this = this;
+                return updateWithAccessorUpdateAndConverterFunction(this.accessor, this.converter)(data, params).then(function(result) {
+                    _this._cache.invalidate();
+                    return result;
+                });
             }
         },
         {
             /**
      * Updates the document using the accessor's increment functionality.
      *
+     * Invalidates the cache entry since increment updates don't provide the full document.
+     *
      * @param data - The increment update to apply to numeric fields
      * @returns A Promise that resolves when the increment update completes
      */ key: "increment",
             value: function increment(data) {
-                return incrementUpdateWithAccessorFunction(this.accessor)(data);
+                var _this = this;
+                return incrementUpdateWithAccessorFunction(this.accessor)(data).then(function(result) {
+                    _this._cache.invalidate();
+                    return result;
+                });
             }
         },
         {
             /**
      * Updates the document using the accessor's array field update functionality.
      *
+     * Invalidates the cache entry since array updates don't provide the full document.
+     *
      * @param data - The array field update to apply (union or remove elements)
      * @returns A Promise that resolves when the array update completes
      */ key: "arrayUpdate",
             value: function arrayUpdate(data) {
-                return arrayUpdateWithAccessorFunction(this.accessor)(data);
+                var _this = this;
+                return arrayUpdateWithAccessorFunction(this.accessor)(data).then(function(result) {
+                    _this._cache.invalidate();
+                    return result;
+                });
             }
         }
     ]);
@@ -1337,7 +1520,7 @@ function _is_native_reflect_construct$8() {
  * @param config - Configuration including converter, accessor factory, and document factory
  * @returns A factory function for creating LimitedFirestoreDocumentAccessor instances
  */ function limitedFirestoreDocumentAccessorFactory(config) {
-    var firestoreContext = config.firestoreContext, firestoreAccessorDriver = config.firestoreAccessorDriver, makeDocument = config.makeDocument, interceptAccessorFactory = config.accessorFactory, inputDefaultConverter = config.converter, inputConverterFactory = config.converterFactory, modelIdentity = config.modelIdentity;
+    var firestoreContext = config.firestoreContext, firestoreAccessorDriver = config.firestoreAccessorDriver, makeDocument = config.makeDocument, interceptAccessorFactory = config.accessorFactory, inputDefaultConverter = config.converter, inputConverterFactory = config.converterFactory, modelIdentity = config.modelIdentity, inputCache = config.cache;
     var expectedCollectionName = firestoreAccessorDriver.fuzzedPathForPath ? firestoreAccessorDriver.fuzzedPathForPath(modelIdentity.collectionName) : modelIdentity.collectionName;
     var converterFactory = inputConverterFactory ? function(ref) {
         var _inputConverterFactory;
@@ -1366,10 +1549,17 @@ function _is_native_reflect_construct$8() {
         };
         var databaseContext = context !== null && context !== void 0 ? context : config.firestoreAccessorDriver.defaultContextFactory();
         var dataAccessorFactory = interceptAccessorFactory ? interceptAccessorFactory(databaseContext.accessorFactory) : databaseContext.accessorFactory;
+        // Transaction/batch contexts bypass cache; otherwise bind the collection cache to the document ref
+        var cacheForDocument = context ? function() {
+            return noopFirestoreCollectionDocumentCache();
+        } : function(ref) {
+            return firestoreCollectionDocumentCache(inputCache, ref.path);
+        };
         var documentAccessor = {
             converter: inputDefaultConverter,
             converterFactory: converterFactory,
             modelIdentity: modelIdentity,
+            cacheForDocument: cacheForDocument,
             loadDocumentFrom: function loadDocumentFrom(document) {
                 return loadDocument(document.documentRef);
             },
@@ -1500,7 +1690,7 @@ var AbstractFirestoreDocumentWithParent = /*#__PURE__*/ function(AbstractFiresto
     x.loadDocumentForWriteBatch = singleAccessor.loadDocumentForWriteBatch;
 }
 
-function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1514,22 +1704,22 @@ function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$h(fn) {
+function _async_to_generator$i(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$i(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _ts_generator$h(thisArg, body) {
+function _ts_generator$i(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -1665,9 +1855,9 @@ function _ts_generator$h(thisArg, body) {
     return util.performMakeLoop({
         count: make.count,
         make: function make1(i) {
-            return _async_to_generator$h(function() {
+            return _async_to_generator$i(function() {
                 var document, data;
-                return _ts_generator$h(this, function(_state) {
+                return _ts_generator$i(this, function(_state) {
                     switch(_state.label){
                         case 0:
                             document = newDocumentFn(documentAccessor);
@@ -2026,9 +2216,9 @@ function documentDataWithIdAndKey(snapshot) {
  * @param defaultValue - Fallback value when `document` is nullish or the snapshot is unavailable
  * @returns The result of `use`, or the default value
  */ function useDocumentSnapshot(document, use, defaultValue) {
-    return _async_to_generator$h(function() {
+    return _async_to_generator$i(function() {
         var snapshot;
-        return _ts_generator$h(this, function(_state) {
+        return _ts_generator$i(this, function(_state) {
             switch(_state.label){
                 case 0:
                     return [
@@ -2155,8 +2345,8 @@ function documentDataWithIdAndKey(snapshot) {
         return cached;
     }
     function getDocumentSnapshotDataPairsForKeys(keys) {
-        return _async_to_generator$h(function() {
-            return _ts_generator$h(this, function(_state) {
+        return _async_to_generator$i(function() {
+            return _ts_generator$i(this, function(_state) {
                 return [
                     2,
                     Promise.all(keys.map(function(key) {
@@ -2167,9 +2357,9 @@ function documentDataWithIdAndKey(snapshot) {
         })();
     }
     function getDocumentSnapshotDataPairsWithDataForKeys(keys) {
-        return _async_to_generator$h(function() {
+        return _async_to_generator$i(function() {
             var pairs;
-            return _ts_generator$h(this, function(_state) {
+            return _ts_generator$i(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         return [
@@ -2311,6 +2501,499 @@ function documentDataWithIdAndKey(snapshot) {
  * @deprecated Use {@link streamDocumentSnapshotsData} instead.
  */ var latestDataFromDocuments = streamDocumentSnapshotsData;
 
+function asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$h(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$h(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$h(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Default TTL used by the in-memory cache when no TTL is specified.
+ *
+ * Set to 5 minutes.
+ */ var IN_MEMORY_CACHE_DEFAULT_TTL = 5 * 60 * 1000;
+/**
+ * Creates an in-memory {@link FirestoreCollectionCacheDelegate} backed by a Map.
+ *
+ * @example
+ * ```ts
+ * const delegate = inMemoryFirestoreCollectionCacheDelegate<UserData>();
+ * ```
+ */ function inMemoryFirestoreCollectionCacheDelegate() {
+    var entries = new Map();
+    return {
+        get: function get(key) {
+            return entries.get(key);
+        },
+        set: function set(key, entry) {
+            return entries.set(key, entry);
+        },
+        delete: function _delete(key) {
+            entries.delete(key);
+        },
+        clear: function clear() {
+            return entries.clear();
+        }
+    };
+}
+/**
+ * Creates a no-storage {@link FirestoreCollectionCacheDelegate} that discards all data.
+ *
+ * Used by {@link readLoggingFirestoreContextCache} where only event emission matters.
+ *
+ * @example
+ * ```ts
+ * const delegate = noopFirestoreCollectionCacheDelegate<UserData>();
+ * ```
+ */ function noopFirestoreCollectionCacheDelegate() {
+    return {
+        get: function get() {
+            return undefined;
+        },
+        set: function set() {},
+        delete: function _delete() {},
+        clear: function clear() {}
+    };
+}
+/**
+ * Creates a {@link FirestoreCollectionCache} with shared TTL, event, and enabled/disabled logic.
+ *
+ * The actual storage is handled by the provided {@link FirestoreCollectionCacheDelegate}.
+ *
+ * @template T - The document data type
+ * @param config - Configuration including TTL, enabled check, event emitter, and delegate
+ * @returns A collection cache instance
+ */ function makeFirestoreCollectionCache(config) {
+    var defaultTtl = config.defaultTtl, isEnabled = config.isEnabled, emitEvent = config.emitEvent, delegate = config.delegate;
+    function isFresh(entry, maxTtl) {
+        var age = Date.now() - entry.cachedAt.getTime();
+        return age < maxTtl;
+    }
+    var cache = {
+        defaultTtl: defaultTtl,
+        get: function get(key, maxTtl) {
+            var result;
+            if (isEnabled()) {
+                var entry = delegate.get(key);
+                var effectiveTtl = maxTtl !== null && maxTtl !== void 0 ? maxTtl : defaultTtl;
+                if (entry && isFresh(entry, effectiveTtl)) {
+                    emitEvent('hit', key);
+                    result = entry;
+                } else {
+                    if (entry) {
+                        delegate.delete(key);
+                    }
+                    emitEvent('miss', key);
+                }
+            }
+            return result;
+        },
+        set: function set(key, input) {
+            if (isEnabled()) {
+                var entry = {
+                    key: key,
+                    data: input.data,
+                    cachedAt: new Date()
+                };
+                delegate.set(key, entry);
+                emitEvent('update', key);
+            }
+        },
+        invalidate: function invalidate(key) {
+            if (isEnabled()) {
+                delegate.delete(key);
+                emitEvent('invalidate', key);
+            }
+        },
+        clear: function clear() {
+            delegate.clear();
+        },
+        instance: function instance() {
+            return makeFirestoreCollectionCacheInstance(cache);
+        },
+        destroy: function destroy() {
+            delegate.clear();
+        }
+    };
+    return cache;
+}
+/**
+ * Creates a {@link FirestoreContextCache} with shared event handling, enable/disable controls,
+ * and per-type management. The actual cache storage for each collection is handled by
+ * delegates created via {@link MakeFirestoreContextCacheConfig.createDelegate}.
+ *
+ * This is the shared foundation used by both {@link inMemoryFirestoreContextCache} and
+ * {@link readLoggingFirestoreContextCache}.
+ *
+ * @param config - Configuration including default TTL and delegate factory
+ * @returns A new context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = makeFirestoreContextCache({
+ *   defaultTtl: 60000,
+ *   createDelegate: () => inMemoryFirestoreCollectionCacheDelegate()
+ * });
+ * ```
+ */ function makeFirestoreContextCache(config) {
+    var globalDefaultTtl = config.defaultTtl, createDelegate = config.createDelegate, mapEvents$ = config.mapEvents$;
+    var collectionCaches = new Map();
+    var disabledTypes = new Set();
+    var eventsSubject = new rxjs$1.Subject();
+    var globalEnabled = true;
+    var rawEvents$ = eventsSubject.asObservable();
+    var events$ = mapEvents$ ? mapEvents$(rawEvents$) : rawEvents$;
+    function emitEvent(type, collectionType, key) {
+        eventsSubject.next({
+            type: type,
+            collectionType: collectionType,
+            key: key !== null && key !== void 0 ? key : null,
+            timestamp: new Date()
+        });
+    }
+    function isEffectivelyEnabled(collectionType) {
+        return globalEnabled && !disabledTypes.has(collectionType);
+    }
+    var contextCache = {
+        cacheForCollection: function cacheForCollection(collectionType, collectionConfig) {
+            var cache = collectionCaches.get(collectionType);
+            if (!cache) {
+                var _collectionConfig_defaultTtl;
+                cache = makeFirestoreCollectionCache({
+                    defaultTtl: (_collectionConfig_defaultTtl = collectionConfig.defaultTtl) !== null && _collectionConfig_defaultTtl !== void 0 ? _collectionConfig_defaultTtl : globalDefaultTtl,
+                    isEnabled: function isEnabled() {
+                        return isEffectivelyEnabled(collectionType);
+                    },
+                    emitEvent: function emitEvent1(type, key) {
+                        return emitEvent(type, collectionType, key);
+                    },
+                    delegate: createDelegate(collectionType)
+                });
+                collectionCaches.set(collectionType, cache);
+            }
+            return cache;
+        },
+        events$: events$,
+        get disabledTypes () {
+            return disabledTypes;
+        },
+        isEnabled: function isEnabled() {
+            return globalEnabled;
+        },
+        setEnabled: function setEnabled(enabled) {
+            globalEnabled = enabled;
+        },
+        clearAll: function clearAll() {
+            collectionCaches.forEach(function(cache) {
+                return cache.clear();
+            });
+        },
+        isEnabledForType: function isEnabledForType(collectionType) {
+            return isEffectivelyEnabled(collectionType);
+        },
+        setEnabledForType: function setEnabledForType(collectionType, enabled) {
+            if (enabled) {
+                disabledTypes.delete(collectionType);
+            } else {
+                disabledTypes.add(collectionType);
+            }
+            var eventType = enabled ? 'enable_collection' : 'disable_collection';
+            emitEvent(eventType, collectionType);
+        },
+        clearForType: function clearForType(collectionType) {
+            var cache = collectionCaches.get(collectionType);
+            if (cache) {
+                cache.clear();
+            }
+        },
+        destroy: function destroy() {
+            eventsSubject.complete();
+            collectionCaches.forEach(function(cache) {
+                return cache.destroy();
+            });
+            collectionCaches.clear();
+        }
+    };
+    return contextCache;
+}
+// MARK: In-Memory Cache
+/**
+ * Creates a {@link FirestoreContextCacheFactory} that stores cached documents in memory.
+ *
+ * Uses simple Map-based storage with TTL-based expiration. Suitable for
+ * client-side caching where the application lifecycle matches the cache lifecycle.
+ *
+ * @returns A factory function that creates in-memory context caches
+ *
+ * @example
+ * ```ts
+ * const factory = inMemoryFirestoreContextCacheFactory();
+ * const contextCache = factory({ defaultTtl: 60000 });
+ * ```
+ */ function inMemoryFirestoreContextCacheFactory() {
+    return function(config) {
+        return inMemoryFirestoreContextCache(config);
+    };
+}
+/**
+ * Creates an in-memory {@link FirestoreContextCache} that manages per-collection
+ * caches with TTL-based expiration, per-type enable/disable, and event streaming.
+ *
+ * @param config - Optional configuration
+ * @returns A new context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = inMemoryFirestoreContextCache({ defaultTtl: 60000 });
+ * const userCache = contextCache.cacheForCollection<UserData>('user', { defaultTtl: 30000 });
+ * userCache.set('users/abc', { data: userData });
+ * ```
+ */ function inMemoryFirestoreContextCache(config) {
+    var _ref;
+    return makeFirestoreContextCache({
+        defaultTtl: (_ref = config === null || config === void 0 ? void 0 : config.defaultTtl) !== null && _ref !== void 0 ? _ref : IN_MEMORY_CACHE_DEFAULT_TTL,
+        createDelegate: function createDelegate() {
+            return inMemoryFirestoreCollectionCacheDelegate();
+        }
+    });
+}
+// MARK: Read-Logging Cache
+/**
+ * Creates a {@link FirestoreContextCacheFactory} that emits events for all cache interactions
+ * but does not actually store any data.
+ *
+ * Useful for analytics, debugging, and monitoring read patterns without the
+ * memory overhead of actual caching.
+ *
+ * @returns A factory function that creates read-logging context caches
+ *
+ * @example
+ * ```ts
+ * const factory = readLoggingFirestoreContextCacheFactory();
+ * const contextCache = factory();
+ * contextCache.events$.subscribe((event) => console.log(event));
+ * ```
+ */ function readLoggingFirestoreContextCacheFactory() {
+    return function(config) {
+        return readLoggingFirestoreContextCache(config);
+    };
+}
+/**
+ * Creates a {@link FirestoreContextCache} that emits events for all cache interactions
+ * but does not actually store any data. Every `get()` call results in a 'miss' event.
+ *
+ * Useful for tracking read patterns, debugging, and monitoring which documents
+ * are accessed and how often, without the memory overhead of actual caching.
+ *
+ * @param config - Optional configuration
+ * @returns A new read-logging context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = readLoggingFirestoreContextCache();
+ * contextCache.events$.subscribe((event) => {
+ *   console.log(`${event.type}: ${event.collectionType} ${event.key}`);
+ * });
+ * ```
+ */ function readLoggingFirestoreContextCache(config) {
+    var _ref;
+    return makeFirestoreContextCache({
+        defaultTtl: (_ref = config === null || config === void 0 ? void 0 : config.defaultTtl) !== null && _ref !== void 0 ? _ref : IN_MEMORY_CACHE_DEFAULT_TTL,
+        createDelegate: function createDelegate() {
+            return noopFirestoreCollectionCacheDelegate();
+        },
+        mapEvents$: function mapEvents$(events$) {
+            return events$.pipe(rxjs$1.filter(function(event) {
+                return event.type !== 'miss';
+            }));
+        }
+    });
+}
+// MARK: Cache Instance
+/**
+ * Creates an operation-scoped {@link FirestoreCollectionCacheInstance} that deduplicates
+ * concurrent reads and uses the parent cache as a warm start.
+ *
+ * @template T - The document data type
+ * @param parentCache - The parent collection cache for warm-start lookups
+ * @returns An operation-scoped cache instance
+ */ function makeFirestoreCollectionCacheInstance(parentCache) {
+    var localEntries = new Map();
+    var inFlight = new Map();
+    var instance = {
+        get: function get(key, maxTtl) {
+            // Check local instance cache first
+            var result = localEntries.get(key);
+            // Fall back to parent cache
+            if (!result) {
+                result = parentCache.get(key, maxTtl);
+                if (result) {
+                    localEntries.set(key, result);
+                }
+            }
+            return result;
+        },
+        getOrFetch: function getOrFetch(key, fetchFn) {
+            return _async_to_generator$h(function() {
+                var cached, existing, fetchPromise;
+                return _ts_generator$h(this, function(_state) {
+                    // Check local cache first
+                    cached = localEntries.get(key);
+                    if (cached) {
+                        return [
+                            2,
+                            cached
+                        ];
+                    }
+                    // Check for in-flight request
+                    existing = inFlight.get(key);
+                    if (existing) {
+                        return [
+                            2,
+                            existing
+                        ];
+                    }
+                    // Start new fetch
+                    fetchPromise = fetchFn().then(function(entry) {
+                        localEntries.set(key, entry);
+                        parentCache.set(key, entry);
+                        inFlight.delete(key);
+                        return entry;
+                    });
+                    inFlight.set(key, fetchPromise);
+                    return [
+                        2,
+                        fetchPromise
+                    ];
+                });
+            })();
+        }
+    };
+    return instance;
+}
+
 /**
  * Platform-agnostic Firestore type definitions.
  *
@@ -7093,9 +7776,14 @@ var FIRESTORE_DUMMY_MODEL_KEY = 'dummymodel/dummykey';
  * @param inputConfig - Configuration for the collection
  * @returns A fully configured FirestoreCollection instance
  */ function makeFirestoreCollection(inputConfig) {
+    var _config_defaultTtl;
     var config = inputConfig;
     var modelIdentity = config.modelIdentity, collection = config.collection, firestoreContext = config.firestoreContext, firestoreAccessorDriver = config.firestoreAccessorDriver;
     config.queryLike = collection;
+    var cache = firestoreContext.cache.cacheForCollection(modelIdentity.collectionType, {
+        defaultTtl: (_config_defaultTtl = config.defaultTtl) !== null && _config_defaultTtl !== void 0 ? _config_defaultTtl : 0
+    });
+    config.cache = cache;
     var documentAccessor = firestoreDocumentAccessorFactory(config);
     var documentAccessorExtension = firestoreDocumentAccessorContextExtension({
         documentAccessor: documentAccessor,
@@ -7108,6 +7796,7 @@ var FIRESTORE_DUMMY_MODEL_KEY = 'dummymodel/dummykey';
     var query = queryFactory.query;
     return _object_spread_props$f(_object_spread$j({
         config: config,
+        cache: cache,
         modelIdentity: modelIdentity,
         collection: collection,
         queryLike: collection,
@@ -7204,7 +7893,12 @@ function _object_spread_props$e(target, source) {
  * @param config - Configuration for the collection group
  * @returns A fully configured FirestoreCollectionGroup instance
  */ function makeFirestoreCollectionGroup(config) {
+    var _config_defaultTtl;
     var modelIdentity = config.modelIdentity, queryLike = config.queryLike, firestoreContext = config.firestoreContext, firestoreAccessorDriver = config.firestoreAccessorDriver;
+    var cache = firestoreContext.cache.cacheForCollection(modelIdentity.collectionType, {
+        defaultTtl: (_config_defaultTtl = config.defaultTtl) !== null && _config_defaultTtl !== void 0 ? _config_defaultTtl : 0
+    });
+    config.cache = cache;
     // Create the document accessor for loading documents
     var documentAccessor = limitedFirestoreDocumentAccessorFactory(config);
     // Create the document accessor extension with context
@@ -7223,6 +7917,7 @@ function _object_spread_props$e(target, source) {
     // Return the fully constructed collection group
     return _object_spread_props$e(_object_spread$i({
         config: config,
+        cache: cache,
         queryLike: queryLike,
         modelIdentity: modelIdentity,
         firestoreContext: firestoreContext
@@ -7381,8 +8076,11 @@ function _unsupported_iterable_to_array$9(o, minLen) {
  * @param drivers - The Firestore drivers to use in created contexts
  * @returns A factory function that creates FirestoreContext instances
  */ function firestoreContextFactory(drivers) {
-    return function(firestore) {
+    return function(firestore, params) {
         var _drivers_firestoreAccessorDriver;
+        var _ref;
+        var _params_firestoreContextCacheFactory;
+        var contextCache = (_ref = params === null || params === void 0 ? void 0 : (_params_firestoreContextCacheFactory = params.firestoreContextCacheFactory) === null || _params_firestoreContextCacheFactory === void 0 ? void 0 : _params_firestoreContextCacheFactory.call(params)) !== null && _ref !== void 0 ? _ref : noopFirestoreContextCache();
         var makeFirestoreCollectionConfig = function makeFirestoreCollectionConfig(config) {
             var collection = config.collection;
             var queryLike = collection !== null && collection !== void 0 ? collection : config.queryLike;
@@ -7405,6 +8103,7 @@ function _unsupported_iterable_to_array$9(o, minLen) {
         var context = {
             firestore: firestore,
             drivers: drivers,
+            cache: contextCache,
             collectionGroup: function collectionGroup(collectionId) {
                 return drivers.firestoreAccessorDriver.collectionGroup(firestore, collectionId);
             },
@@ -8750,8 +9449,13 @@ var _obj;
  *
  * @example
  * ```ts
+ * // Without caching
  * const context = clientFirebaseFirestoreContextFactory(firestore);
- * const collection = context.collection(myCollectionConfig);
+ *
+ * // With caching
+ * const context = clientFirebaseFirestoreContextFactory(firestore, {
+ *   firestoreContextCacheFactory: inMemoryFirestoreContextCacheFactory()
+ * });
  * ```
  */ var clientFirebaseFirestoreContextFactory = firestoreContextFactory(firebaseFirestoreClientDrivers());
 
@@ -18184,6 +18888,7 @@ exports.FirebaseDevelopmentFunctions = FirebaseDevelopmentFunctions;
 exports.FirebaseModelPermissionServiceInstance = FirebaseModelPermissionServiceInstance;
 exports.FirebaseServerError = FirebaseServerError;
 exports.HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = HIGH_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
+exports.IN_MEMORY_CACHE_DEFAULT_TTL = IN_MEMORY_CACHE_DEFAULT_TTL;
 exports.LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL = LOW_UPLOADED_FILE_TYPE_DETERMINATION_LEVEL;
 exports.MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MAX_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
 exports.MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE = MIN_FIRESTORE_MAP_ZOOM_LEVEL_VALUE;
@@ -18378,6 +19083,7 @@ exports.firestoreBoolean = firestoreBoolean;
 exports.firestoreClientAccessorDriver = firestoreClientAccessorDriver;
 exports.firestoreClientArrayUpdateToUpdateData = firestoreClientArrayUpdateToUpdateData;
 exports.firestoreClientIncrementUpdateToUpdateData = firestoreClientIncrementUpdateToUpdateData;
+exports.firestoreCollectionDocumentCache = firestoreCollectionDocumentCache;
 exports.firestoreCollectionQueryFactory = firestoreCollectionQueryFactory;
 exports.firestoreContextFactory = firestoreContextFactory;
 exports.firestoreDate = firestoreDate;
@@ -18507,6 +19213,9 @@ exports.grantModelRolesOnlyIfFunction = grantModelRolesOnlyIfFunction;
 exports.grantStorageFileRolesForUserAuthFunction = grantStorageFileRolesForUserAuthFunction;
 exports.inContextFirebaseModelServiceFactory = inContextFirebaseModelServiceFactory;
 exports.inContextFirebaseModelsServiceFactory = inContextFirebaseModelsServiceFactory;
+exports.inMemoryFirestoreCollectionCacheDelegate = inMemoryFirestoreCollectionCacheDelegate;
+exports.inMemoryFirestoreContextCache = inMemoryFirestoreContextCache;
+exports.inMemoryFirestoreContextCacheFactory = inMemoryFirestoreContextCacheFactory;
 exports.incrementUpdateWithAccessorFunction = incrementUpdateWithAccessorFunction;
 exports.inferKeyFromTwoWayFlatFirestoreModelKey = inferKeyFromTwoWayFlatFirestoreModelKey;
 exports.inferNotificationBoxRelatedModelKey = inferNotificationBoxRelatedModelKey;
@@ -18563,6 +19272,7 @@ exports.makeDocuments = makeDocuments;
 exports.makeFirestoreCollection = makeFirestoreCollection;
 exports.makeFirestoreCollectionGroup = makeFirestoreCollectionGroup;
 exports.makeFirestoreCollectionWithParent = makeFirestoreCollectionWithParent;
+exports.makeFirestoreContextCache = makeFirestoreContextCache;
 exports.makeFirestoreItemPageIteratorDelegate = makeFirestoreItemPageIteratorDelegate;
 exports.makeFirestoreQueryConstraintFunctionsDriver = makeFirestoreQueryConstraintFunctionsDriver;
 exports.makeRootSingleItemFirestoreCollection = makeRootSingleItemFirestoreCollection;
@@ -18582,6 +19292,10 @@ exports.newDocuments = newDocuments;
 exports.newNotificationBoxRecipientForUid = newNotificationBoxRecipientForUid;
 exports.noContentNotificationMessageFunctionFactory = noContentNotificationMessageFunctionFactory;
 exports.noStringFormatInStorageUploadOptionsError = noStringFormatInStorageUploadOptionsError;
+exports.noopFirestoreCollectionCache = noopFirestoreCollectionCache;
+exports.noopFirestoreCollectionCacheDelegate = noopFirestoreCollectionCacheDelegate;
+exports.noopFirestoreCollectionDocumentCache = noopFirestoreCollectionDocumentCache;
+exports.noopFirestoreContextCache = noopFirestoreContextCache;
 exports.notificationBoxCollectionReference = notificationBoxCollectionReference;
 exports.notificationBoxConverter = notificationBoxConverter;
 exports.notificationBoxFirestoreCollection = notificationBoxFirestoreCollection;
@@ -18673,6 +19387,8 @@ exports.processAllQueuedStorageFilesParamsType = processAllQueuedStorageFilesPar
 exports.processStorageFileParamsType = processStorageFileParamsType;
 exports.readFirestoreModelKey = readFirestoreModelKey;
 exports.readFirestoreModelKeyFromDocumentSnapshot = readFirestoreModelKeyFromDocumentSnapshot;
+exports.readLoggingFirestoreContextCache = readLoggingFirestoreContextCache;
+exports.readLoggingFirestoreContextCacheFactory = readLoggingFirestoreContextCacheFactory;
 exports.regenerateAllFlaggedStorageFileGroupsContentParamsType = regenerateAllFlaggedStorageFileGroupsContentParamsType;
 exports.regenerateStorageFileGroupContentParamsType = regenerateStorageFileGroupContentParamsType;
 exports.replaceConstraints = replaceConstraints;