@dereekb/firebase 13.0.5 → 13.0.6

package/index.cjs.js

@@ -662,31 +662,33 @@ function extendFirestoreCollectionWithSingleDocumentAccessor(x, singleItemIdenti
 }
 
 /**
- * Creates an array of new FirestoreDocument instances without creating them in Firestore.
+ * Creates an array of new {@link FirestoreDocument} instances without persisting them to Firestore.
  *
- * @template T - The document data type
- * @template D - The FirestoreDocument implementation type
- * @param documentAccessor - The document accessor to use for creating document instances
- * @param count - The number of document instances to create
- * @returns An array of new document instances
+ * Each document is allocated a unique auto-generated ID via {@link FirestoreDocumentAccessor.newDocument},
+ * but no data is written to the database. Useful for preparing document references in bulk before
+ * deciding what data to write.
+ *
+ * @param documentAccessor - Accessor that provides the `newDocument()` factory method
+ * @param count - Number of document instances to create
+ * @returns Array of `count` new document instances, each with a unique auto-generated ID
  */
 function newDocuments(documentAccessor, count) {
     return util.makeWithFactory(() => documentAccessor.newDocument(), count);
 }
 /**
- * Creates multiple documents in Firestore and returns the document instances.
+ * Creates and optionally persists multiple Firestore documents in sequence.
  *
- * For each document, this function:
- * 1. Creates a new document instance using the specified or default factory
- * 2. Calls the init function with the document instance
- * 3. If init returns data, creates the document in Firestore
- * 4. Returns all document instances, whether they were created in Firestore or not
+ * Uses {@link performMakeLoop} to iterate `count` times. For each iteration:
+ * 1. A new document instance is created (via `make.newDocument` or the default factory)
+ * 2. `make.init(i, document)` is awaited to produce initial data
+ * 3. If init returns non-nullish data, `document.accessor.create(data)` persists it
+ * 4. The document instance is collected regardless of whether it was persisted
  *
- * @template T - The document data type
- * @template D - The FirestoreDocument implementation type
- * @param documentAccessor - The document accessor to use for creating document instances
- * @param make - Parameters for document creation and initialization
- * @returns A promise that resolves to an array of document instances
+ * Documents are created sequentially (not in parallel) to allow index-dependent logic.
+ *
+ * @param documentAccessor - Accessor providing the document factory and collection context
+ * @param make - Configuration controlling count, factory, and initialization
+ * @returns Promise resolving to all created document instances (length === `make.count`)
  */
 function makeDocuments(documentAccessor, make) {
     const newDocumentFn = make.newDocument ?? (() => documentAccessor.newDocument());
@@ -703,65 +705,52 @@ function makeDocuments(documentAccessor, make) {
     });
 }
 /**
- * Retrieves DocumentSnapshots for an array of documents in parallel.
+ * Fetches {@link DocumentSnapshot}s for multiple documents in parallel using {@link runAsyncTasksForValues}.
  *
- * This is useful for fetching the current state of multiple documents at once.
+ * Each document's `accessor.get()` is called concurrently. The returned array preserves
+ * the same ordering as the input `documents` array.
  *
- * @template D - The FirestoreDocument implementation type
- * @param documents - Array of document instances to get snapshots for
- * @returns Promise that resolves to an array of DocumentSnapshots in the same order as the input documents
+ * @param documents - Documents to fetch snapshots for
+ * @returns Snapshots in the same order as the input array
  */
 function getDocumentSnapshots(documents) {
     return util.runAsyncTasksForValues(documents, (x) => x.accessor.get());
 }
 /**
- * Creates a document-snapshot pair from a document instance.
+ * Fetches the current snapshot of a single document and pairs it with the document instance.
  *
- * Fetches the current snapshot of the document and returns both the original
- * document instance and the snapshot together.
- *
- * @template D - The FirestoreDocument implementation type
- * @param document - The document instance to get a snapshot for
- * @returns Promise that resolves to a document-snapshot pair
+ * @param document - The document to fetch
+ * @returns A pair containing the document and its snapshot
  */
 function getDocumentSnapshotPair(document) {
     return document.accessor.get().then((snapshot) => ({ document, snapshot }));
 }
 /**
- * Creates document-snapshot pairs for an array of documents in parallel.
+ * Fetches snapshots for multiple documents in parallel and pairs each with its document instance.
  *
- * Fetches the current snapshot of each document and returns pairs containing both
- * the original document instances and their snapshots.
- *
- * @template D - The FirestoreDocument implementation type
- * @param documents - Array of document instances to get snapshots for
- * @returns Promise that resolves to an array of document-snapshot pairs in the same order as the input documents
+ * @param documents - Documents to fetch
+ * @returns Pairs in the same order as the input array
  */
 function getDocumentSnapshotPairs(documents) {
     return util.runAsyncTasksForValues(documents, getDocumentSnapshotPair);
 }
 /**
- * Creates a document-snapshot-data triplet from a document instance.
+ * Fetches a document's snapshot, extracts its data with `id`/`key` fields, and returns all three as a triplet.
  *
- * Fetches the current snapshot of the document, extracts its data with ID and key fields,
- * and returns all three together in a single object.
- *
- * @template D - The FirestoreDocument implementation type
- * @param document - The document instance to get data for
- * @returns Promise that resolves to a document-snapshot-data triplet
+ * @param document - The document to fetch
+ * @returns A triplet of document, snapshot, and data (data may be `undefined` if the document doesn't exist)
  */
 function getDocumentSnapshotDataPair(document) {
     return document.accessor.get().then((snapshot) => ({ document, snapshot, data: documentDataWithIdAndKey(snapshot) }));
 }
 /**
- * Creates document-snapshot-data triplets for an array of documents in parallel.
+ * Fetches snapshot-data triplets for multiple documents in parallel.
  *
- * Fetches the current snapshot of each document, extracts its data with ID and key fields,
- * and returns triplets containing all three components for each document.
+ * Processes up to 200 documents concurrently via {@link runAsyncTasksForValues}.
+ * The returned array preserves the same ordering as the input.
  *
- * @template D - The FirestoreDocument implementation type
- * @param documents - Array of document instances to get data for
- * @returns Promise that resolves to an array of document-snapshot-data triplets in the same order as the input documents
+ * @param documents - Documents to fetch
+ * @returns Triplets in the same order as the input array
  */
 function getDocumentSnapshotDataPairs(documents) {
     return util.runAsyncTasksForValues(documents, getDocumentSnapshotDataPair, {
@@ -769,18 +758,27 @@ function getDocumentSnapshotDataPairs(documents) {
     });
 }
 /**
- * Creates document-snapshot-data triplets for an array of documents and filters out those without data.
+ * Fetches snapshot-data triplets for multiple documents and filters out those that don't exist in Firestore.
  *
- * This is a convenience function that fetches data for all documents and then returns
- * only the triplets for documents that actually exist in Firestore.
+ * Convenience wrapper around {@link getDocumentSnapshotDataPairs} that removes entries where `data` is nullish,
+ * returning only {@link FirestoreDocumentSnapshotDataPairWithData} results.
  *
- * @template D - The FirestoreDocument implementation type
- * @param documents - Array of document instances to get data for
- * @returns Promise that resolves to an array of document-snapshot-data triplets for existing documents only
+ * @param documents - Documents to fetch
+ * @returns Triplets for documents that exist, in their original relative order
  */
 function getDocumentSnapshotDataPairsWithData(documents) {
     return getDocumentSnapshotDataPairs(documents).then((x) => x.filter((y) => !!y.data));
 }
+/**
+ * Fetches raw snapshot data tuples for multiple documents in parallel.
+ *
+ * Unlike {@link getDocumentSnapshotDataPairs}, this returns a lightweight `[document, data]` tuple
+ * and does not inject `id`/`key` fields onto the data. The `data` value is the raw result of
+ * `snapshot.data()` and may be `undefined` for non-existent documents.
+ *
+ * @param documents - Documents to fetch
+ * @returns Tuples in the same order as the input array
+ */
 function getDocumentSnapshotDataTuples(documents) {
     return util.runAsyncTasksForValues(documents, (document) => document.accessor.get().then((snapshot) => [document, snapshot.data()]));
 }
@@ -794,33 +792,109 @@ function getDataFromDocumentSnapshots(snapshots, withId = true) {
     const mapFn = documentDataFunction(withId);
     return util.filterMaybeArrayValues(snapshots.map(mapFn));
 }
+/**
+ * Creates {@link FirestoreDocument} instances for all documents in a {@link QuerySnapshot}.
+ *
+ * Maps each document in `snapshots.docs` to a loaded document via `accessor.loadDocument(ref)`.
+ * No additional data fetching occurs; the documents are loaded from their existing references.
+ *
+ * @param accessor - Accessor to load documents with
+ * @param snapshots - Query snapshot containing the document references
+ * @returns Document instances in the same order as the query results
+ */
 function loadDocumentsForSnapshots(accessor, snapshots) {
     return snapshots.docs.map((x) => accessor.loadDocument(x.ref));
 }
+/**
+ * Extracts {@link DocumentReference}s from arbitrary values and loads them as {@link FirestoreDocument} instances.
+ *
+ * Convenience function that maps values through `getRef` then delegates to {@link loadDocumentsForDocumentReferences}.
+ *
+ * @param accessor - Accessor to load documents with
+ * @param values - Source values to extract references from
+ * @param getRef - Extracts a document reference from each value
+ * @returns Document instances in the same order as the input values
+ */
 function loadDocumentsForDocumentReferencesFromValues(accessor, values, getRef) {
     return loadDocumentsForDocumentReferences(accessor, values.map(getRef));
 }
+/**
+ * Alias for {@link loadDocumentsForDocumentReferencesFromValues}.
+ */
 const loadDocumentsForValues = loadDocumentsForDocumentReferencesFromValues;
+/**
+ * Loads {@link FirestoreDocument} instances from an array of {@link DocumentReference}s.
+ *
+ * Each reference is passed to `accessor.loadDocument()` to create a document wrapper.
+ * No network calls are made; this only creates in-memory document instances bound to the given references.
+ *
+ * @param accessor - Accessor to load documents with
+ * @param refs - Document references to load
+ * @returns Document instances in the same order as the input references
+ */
 function loadDocumentsForDocumentReferences(accessor, refs) {
     return refs.map((x) => accessor.loadDocument(x));
 }
+/**
+ * Extracts {@link FirestoreModelKey}s from arbitrary values and loads them as {@link FirestoreDocument} instances.
+ *
+ * Convenience function that maps values through `getKey` then delegates to {@link loadDocumentsForKeys}.
+ *
+ * @param accessor - Accessor to load documents with
+ * @param values - Source values to extract keys from
+ * @param getKey - Extracts a model key (full Firestore path) from each value
+ * @returns Document instances in the same order as the input values
+ */
 function loadDocumentsForKeysFromValues(accessor, values, getKey) {
     return loadDocumentsForKeys(accessor, values.map(getKey));
 }
+/**
+ * Loads {@link FirestoreDocument} instances from an array of full Firestore document paths (keys).
+ *
+ * Each key is passed to `accessor.loadDocumentForKey()`. No network calls are made.
+ *
+ * @param accessor - Accessor to load documents with
+ * @param keys - Full Firestore document paths (e.g. `'users/abc123'`)
+ * @returns Document instances in the same order as the input keys
+ */
 function loadDocumentsForKeys(accessor, keys) {
     return keys.map((x) => accessor.loadDocumentForKey(x));
 }
+/**
+ * Extracts {@link FirestoreModelId}s from arbitrary values and loads them as {@link FirestoreDocument} instances.
+ *
+ * Convenience function that maps values through `getId` then delegates to {@link loadDocumentsForIds}.
+ * Requires a full {@link FirestoreDocumentAccessor} (not limited) because loading by ID requires collection context.
+ *
+ * @param accessor - Accessor to load documents with (must have collection context for ID resolution)
+ * @param values - Source values to extract IDs from
+ * @param getId - Extracts a model ID from each value
+ * @returns Document instances in the same order as the input values
+ */
 function loadDocumentsForIdsFromValues(accessor, values, getId) {
     return loadDocumentsForIds(accessor, values.map(getId));
 }
+/**
+ * Loads {@link FirestoreDocument} instances from an array of document IDs relative to the accessor's collection.
+ *
+ * Each ID is passed to `accessor.loadDocumentForId()`. Requires a full {@link FirestoreDocumentAccessor}
+ * because ID-based loading needs the collection reference to resolve the full path. No network calls are made.
+ *
+ * @param accessor - Accessor to load documents with (must have collection context)
+ * @param ids - Document IDs within the accessor's collection
+ * @returns Document instances in the same order as the input IDs
+ */
 function loadDocumentsForIds(accessor, ids) {
     return ids.map((x) => accessor.loadDocumentForId(x));
 }
 /**
- * Used to make a FirestoreDocumentLoader.
+ * Creates a {@link FirestoreDocumentLoader} from a {@link LimitedFirestoreDocumentAccessorContextExtension}.
  *
- * @param accessorContext
- * @returns
+ * The returned loader resolves the appropriate accessor based on whether a transaction is provided,
+ * then delegates to {@link loadDocumentsForDocumentReferences}.
+ *
+ * @param accessorContext - Context that provides accessors for both default and transactional use
+ * @returns A loader function that converts document references to document instances
  */
 function firestoreDocumentLoader(accessorContext) {
     return (references, transaction) => {
@@ -829,10 +903,16 @@ function firestoreDocumentLoader(accessorContext) {
     };
 }
 /**
- * Used to make a FirestoreDocumentSnapshotPairsLoader.
+ * Creates a {@link FirestoreDocumentSnapshotPairsLoader} from a {@link LimitedFirestoreDocumentAccessorContextExtension}.
  *
- * @param accessorContext
- * @returns
+ * The returned loader resolves the appropriate accessor based on whether a transaction is provided,
+ * then maps each snapshot to a {@link FirestoreDocumentSnapshotDataPair} using {@link firestoreDocumentSnapshotPairsLoaderInstance}.
+ *
+ * Also satisfies the {@link FirestoreQueryDocumentSnapshotPairsLoader} type since the implementation
+ * handles both {@link DocumentSnapshot} and {@link QueryDocumentSnapshot} inputs.
+ *
+ * @param accessorContext - Context that provides accessors for both default and transactional use
+ * @returns A loader function that converts snapshots to document-snapshot-data pairs
  */
 function firestoreDocumentSnapshotPairsLoader(accessorContext) {
     return (snapshots, transaction) => {
@@ -842,10 +922,15 @@ function firestoreDocumentSnapshotPairsLoader(accessorContext) {
     };
 }
 /**
- * Used to make a FirestoreDocumentSnapshotPairsLoader.
+ * Creates a {@link FirestoreDocumentSnapshotPairsLoaderInstance} bound to a specific accessor.
  *
- * @param accessorContext
- * @returns
+ * The returned function converts a snapshot into a {@link FirestoreDocumentSnapshotDataPair} by:
+ * 1. Extracting data with `id`/`key` fields via {@link documentDataWithIdAndKey}
+ * 2. Loading the document from the snapshot's reference via `accessor.loadDocument()`
+ * 3. Combining all three into a single pair object
+ *
+ * @param accessor - The accessor to bind for document loading
+ * @returns A reusable function that converts snapshots to pairs using the bound accessor
  */
 function firestoreDocumentSnapshotPairsLoaderInstance(accessor) {
     const fn = ((snapshot) => {
@@ -862,10 +947,10 @@ function firestoreDocumentSnapshotPairsLoaderInstance(accessor) {
     return fn;
 }
 /**
- * Used to make a FirestoreQueryDocumentSnapshotPairsLoader.
+ * Alias for {@link firestoreDocumentSnapshotPairsLoader}, typed specifically as a {@link FirestoreQueryDocumentSnapshotPairsLoader}.
  *
- * @param accessorContext
- * @returns
+ * Use this when you know all input snapshots are from a query and want the stronger return type
+ * that guarantees `data` is non-nullish.
  */
 const firestoreQueryDocumentSnapshotPairsLoader = firestoreDocumentSnapshotPairsLoader;
 function documentData(snapshot, withId = false) {
@@ -887,11 +972,14 @@ function documentDataWithIdAndKey(snapshot) {
     return data;
 }
 /**
- * Sets the id and key values from the snapshot onto the input data.
+ * Mutates the input data object to include `id` and `key` fields from a {@link DocumentSnapshot}.
  *
- * @param data
- * @param snapshot
- * @returns
+ * Sets `data.id` to `snapshot.id` and `data.key` to `snapshot.ref.path`. The data object
+ * is modified in-place and also returned for chaining convenience.
+ *
+ * @param data - The data object to augment (mutated in-place)
+ * @param snapshot - Source of the `id` and `key` values
+ * @returns The same data object, now typed as {@link DocumentDataWithIdAndKey}
  */
 function setIdAndKeyFromSnapshotOnDocumentData(data, snapshot) {
     const target = data;
@@ -900,11 +988,15 @@ function setIdAndKeyFromSnapshotOnDocumentData(data, snapshot) {
     return target;
 }
 /**
- * Sets the id and key values from the snapshot onto the input data.
+ * Mutates the input data object to include `id` and `key` fields from a model reference.
  *
- * @param data
- * @param snapshot
- * @returns
+ * Similar to {@link setIdAndKeyFromSnapshotOnDocumentData}, but sources the values from a
+ * {@link FirestoreModelKeyRef} & {@link FirestoreModelIdRef} instead of a snapshot.
+ * The data object is modified in-place and also returned for chaining convenience.
+ *
+ * @param data - The data object to augment (mutated in-place)
+ * @param modelRef - Source of the `id` and `key` values
+ * @returns The same data object, now typed as {@link DocumentDataWithIdAndKey}
  */
 function setIdAndKeyFromKeyIdRefOnDocumentData(data, modelRef) {
     const target = data;
@@ -913,37 +1005,91 @@ function setIdAndKeyFromKeyIdRefOnDocumentData(data, modelRef) {
     return target;
 }
 /**
- * MappedUseAsyncFunction to load a snapshot from the input document and use it.
+ * Fetches a document's snapshot and passes it to a `use` callback, following the {@link UseAsync} pattern.
  *
- * @param document
- * @param use
- * @param defaultValue
- * @returns
+ * If `document` is nullish, the `use` callback is not invoked and `defaultValue` is returned instead.
+ * If `document` exists but the snapshot is nullish (shouldn't happen in practice), `defaultValue` is also used.
+ *
+ * @param document - The document to fetch, or nullish to skip
+ * @param use - Callback that receives the fetched snapshot and returns a result
+ * @param defaultValue - Fallback value when `document` is nullish or the snapshot is unavailable
+ * @returns The result of `use`, or the default value
  */
 async function useDocumentSnapshot(document, use, defaultValue) {
     const snapshot = await document?.accessor.get();
     return util.useAsync(snapshot, use, defaultValue);
 }
 /**
- * MappedUseAsyncFunction to load snapshot data from the input document and use it.
+ * Fetches a document's snapshot data (via `snapshot.data()`) and passes it to a `use` callback.
+ *
+ * Wraps {@link useDocumentSnapshot} with a mapping step that extracts raw data from the snapshot.
+ * If the document doesn't exist (data is `undefined`), the `use` callback is not invoked
+ * and `defaultValue` is returned instead.
+ *
+ * @param document - The document to fetch, or nullish to skip
+ * @param use - Callback that receives the snapshot data and returns a result
+ * @param defaultValue - Fallback value when the document is nullish or doesn't exist
+ * @returns The result of `use`, or the default value
  */
 const useDocumentSnapshotData = util.wrapUseAsyncFunction(useDocumentSnapshot, (x) => x.data());
 // MARK: Key Accessors
+/**
+ * Extracts the document ID ({@link FirestoreModelId}) from a {@link FirestoreDocument}.
+ *
+ * Useful as a mapper function, e.g. `documents.map(firestoreModelIdFromDocument)`.
+ *
+ * @param document - The document to extract the ID from
+ * @returns The document's ID (the last segment of its Firestore path)
+ */
 function firestoreModelIdFromDocument(document) {
     return document.id;
 }
+/**
+ * Extracts document IDs from an array of {@link FirestoreDocument}s.
+ *
+ * @param documents - Documents to extract IDs from
+ * @returns Array of document IDs in the same order as the input
+ */
 function firestoreModelIdsFromDocuments(documents) {
     return documents.map(firestoreModelIdFromDocument);
 }
+/**
+ * Extracts the full Firestore path ({@link FirestoreModelKey}) from a {@link FirestoreDocument}.
+ *
+ * Useful as a mapper function, e.g. `documents.map(firestoreModelKeyFromDocument)`.
+ *
+ * @param document - The document to extract the key from
+ * @returns The document's full Firestore path (e.g. `'users/abc123'`)
+ */
 function firestoreModelKeyFromDocument(document) {
     return document.key;
 }
+/**
+ * Extracts full Firestore paths from an array of {@link FirestoreDocument}s.
+ *
+ * @param documents - Documents to extract keys from
+ * @returns Array of full Firestore paths in the same order as the input
+ */
 function firestoreModelKeysFromDocuments(documents) {
     return documents.map(firestoreModelKeyFromDocument);
 }
+/**
+ * Extracts the {@link DocumentReference} from a {@link FirestoreDocument}.
+ *
+ * Useful as a mapper function, e.g. `documents.map(documentReferenceFromDocument)`.
+ *
+ * @param document - The document to extract the reference from
+ * @returns The underlying Firestore document reference
+ */
 function documentReferenceFromDocument(document) {
     return document.documentRef;
 }
+/**
+ * Extracts {@link DocumentReference}s from an array of {@link FirestoreDocument}s.
+ *
+ * @param documents - Documents to extract references from
+ * @returns Array of document references in the same order as the input
+ */
 function documentReferencesFromDocuments(documents) {
     return documents.map(documentReferenceFromDocument);
 }
@@ -953,7 +1099,7 @@ function documentReferencesFromDocuments(documents) {
  *
  * This function streams the latest snapshots for each document in the provided array.
  * Each time any document in the array changes, a new array containing the latest snapshots
- * of all documents is emitted. Results are shared with multiple subscribers through shareReplay.
+ * of all documents is emitted.
  *
  * If the input array is empty, an Observable that emits an empty array is returned.
  *
@@ -962,7 +1108,25 @@ function documentReferencesFromDocuments(documents) {
  * @returns Observable that emits arrays of DocumentSnapshots whenever any document changes
  */
 function latestSnapshotsFromDocuments(documents) {
-    return documents.length ? rxjs$1.combineLatest(documents.map((x) => x.accessor.stream())).pipe(rxjs$1.shareReplay(1)) : rxjs$1.of([]);
+    return mapLatestSnapshotsFromDocuments(documents, rxjs$1.map(util.MAP_IDENTITY));
+}
+/**
+ * Creates an Observable that streams and transforms snapshots for multiple documents using `combineLatest`.
+ *
+ * Pipes each document's `accessor.stream()` through the provided `operator` before combining.
+ * This ensures the transformation runs per-document when only one document changes, rather than
+ * re-mapping all snapshots on every emission.
+ *
+ * {@link latestSnapshotsFromDocuments} delegates to this function with an identity operator.
+ *
+ * Returns `of([])` for an empty input array.
+ *
+ * @param documents - Documents to stream from
+ * @param operator - RxJS operator applied to each document's snapshot stream individually
+ * @returns Observable emitting an array of transformed values whenever any document changes
+ */
+function mapLatestSnapshotsFromDocuments(documents, operator) {
+    return documents.length ? rxjs$1.combineLatest(documents.map((x) => x.accessor.stream().pipe(operator))) : rxjs$1.of([]);
 }
 /**
  * Creates an Observable that emits arrays of document data for multiple documents.
@@ -970,7 +1134,7 @@ function latestSnapshotsFromDocuments(documents) {
  * This function streams the latest data for each document in the provided array.
  * Each time any document in the array changes, a new array containing the latest data
  * of all documents is emitted. Document data includes both the document content and
- * metadata like document ID and key. Results are shared with multiple subscribers.
+ * metadata like document ID and key.
  *
  * Non-existent documents are filtered out of the results automatically.
  *
@@ -979,7 +1143,7 @@ function latestSnapshotsFromDocuments(documents) {
  * @returns Observable that emits arrays of document data whenever any document changes
  */
 function latestDataFromDocuments(documents) {
-    return latestSnapshotsFromDocuments(documents).pipe(dataFromDocumentSnapshots(), rxjs$1.shareReplay(1));
+    return latestSnapshotsFromDocuments(documents).pipe(dataFromDocumentSnapshots());
 }
 /**
  * Creates an RxJS operator that transforms arrays of DocumentSnapshots into arrays of document data.
@@ -994,6 +1158,48 @@ function latestDataFromDocuments(documents) {
 function dataFromDocumentSnapshots() {
     return rxjs$1.map((x) => getDataFromDocumentSnapshots(x));
 }
+// MARK: Streaming Document Snapshot Pairs
+/**
+ * Streams {@link FirestoreDocumentSnapshotDataPair}s for multiple documents using `combineLatest`.
+ *
+ * Each document's `accessor.stream()` is individually piped to produce a `{ document, snapshot, data }` triplet,
+ * then all streams are combined via `combineLatest`. This ensures the mapping only runs for the document
+ * that actually changed. The `data` field has `id` and `key` fields injected via {@link documentDataWithIdAndKey},
+ * and will be `undefined` for documents that don't exist in Firestore.
+ *
+ * Returns `of([])` for an empty input array.
+ *
+ * This is the streaming equivalent of {@link import('./document.utility').getDocumentSnapshotDataPairs}.
+ *
+ * @param documents - Documents to stream snapshot-data pairs for
+ * @returns Observable emitting snapshot-data pairs whenever any document changes
+ */
+function streamDocumentSnapshotDataPairs(documents) {
+    return documents.length
+        ? rxjs$1.combineLatest(documents.map((document) => document.accessor.stream().pipe(rxjs$1.map((snapshot) => ({
+            document,
+            snapshot,
+            data: documentDataWithIdAndKey(snapshot)
+        })))))
+        : rxjs$1.of([]);
+}
+/**
+ * Streams {@link FirestoreDocumentSnapshotDataPairWithData}s for multiple documents, filtering out non-existent documents.
+ *
+ * Builds on {@link streamDocumentSnapshotDataPairs} and filters each emission to include only pairs where
+ * `data` is non-nullish (i.e., the document exists in Firestore). The filtered array may be shorter than
+ * the input `documents` array and may change length over time as documents are created or deleted.
+ *
+ * Returns `of([])` for an empty input array.
+ *
+ * This is the streaming equivalent of {@link import('./document.utility').getDocumentSnapshotDataPairsWithData}.
+ *
+ * @param documents - Documents to stream snapshot-data pairs for
+ * @returns Observable emitting snapshot-data pairs for existing documents only, whenever any document changes
+ */
+function streamDocumentSnapshotDataPairsWithData(documents) {
+    return streamDocumentSnapshotDataPairs(documents).pipe(rxjs$1.map((pairs) => pairs.filter((pair) => pair.data != null)));
+}
 
 // A set of copied types from @google-cloud/firestore and firebase/firestore to allow cross-compatability.
 /* eslint-disable */
@@ -9723,6 +9929,7 @@ exports.makeRootSingleItemFirestoreCollection = makeRootSingleItemFirestoreColle
 exports.makeSingleItemFirestoreCollection = makeSingleItemFirestoreCollection;
 exports.mapDataFromSnapshot = mapDataFromSnapshot;
 exports.mapHttpsCallable = mapHttpsCallable;
+exports.mapLatestSnapshotsFromDocuments = mapLatestSnapshotsFromDocuments;
 exports.mergeNotificationBoxRecipientTemplateConfigRecords = mergeNotificationBoxRecipientTemplateConfigRecords;
 exports.mergeNotificationBoxRecipientTemplateConfigs = mergeNotificationBoxRecipientTemplateConfigs;
 exports.mergeNotificationBoxRecipients = mergeNotificationBoxRecipients;
@@ -9855,6 +10062,8 @@ exports.storageListFilesResultFactory = storageListFilesResultFactory;
 exports.storageListFilesResultHasNoNextError = storageListFilesResultHasNoNextError;
 exports.storagePathFactory = storagePathFactory;
 exports.storedFileReaderFactory = storedFileReaderFactory;
+exports.streamDocumentSnapshotDataPairs = streamDocumentSnapshotDataPairs;
+exports.streamDocumentSnapshotDataPairsWithData = streamDocumentSnapshotDataPairsWithData;
 exports.streamFromOnSnapshot = streamFromOnSnapshot;
 exports.systemStateCollectionReference = systemStateCollectionReference;
 exports.systemStateConverter = systemStateConverter;