@angular/fire 7.6.1 → 16.0.0-canary.596e208

package/esm2022/compat/firestore/collection-group/collection-group.mjs

@@ -0,0 +1,86 @@
+import { from } from 'rxjs';
+import { fromCollectionRef } from '../observable/fromRef';
+import { filter, map, scan } from 'rxjs/operators';
+import { keepUnstableUntilFirst } from '@angular/fire';
+import { validateEventsArray } from '../collection/collection';
+import { docChanges, sortedChanges } from '../collection/changes';
+/**
+ * AngularFirestoreCollectionGroup service
+ *
+ * This class holds a reference to a Firestore Collection Group Query.
+ *
+ * This class uses Symbol.observable to transform into Observable using Observable.from().
+ *
+ * This class is rarely used directly and should be created from the AngularFirestore service.
+ *
+ * Example:
+ *
+ * const collectionGroup = firebase.firestore.collectionGroup('stocks');
+ * const query = collectionRef.where('price', '>', '0.01');
+ * const fakeStock = new AngularFirestoreCollectionGroup<Stock>(query, afs);
+ *
+ * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.
+ * fakeStock.valueChanges().subscribe(value => console.log(value));
+ */
+export class AngularFirestoreCollectionGroup {
+    query;
+    afs;
+    /**
+     * The constructor takes in a CollectionGroupQuery to provide wrapper methods
+     * for data operations and data streaming.
+     */
+    constructor(query, afs) {
+        this.query = query;
+        this.afs = afs;
+    }
+    /**
+     * Listen to the latest change in the stream. This method returns changes
+     * as they occur and they are not sorted by query order. This allows you to construct
+     * your own data structure.
+     */
+    stateChanges(events) {
+        if (!events || events.length === 0) {
+            return docChanges(this.query, this.afs.schedulers.outsideAngular).pipe(keepUnstableUntilFirst);
+        }
+        return docChanges(this.query, this.afs.schedulers.outsideAngular)
+            .pipe(map(actions => actions.filter(change => events.indexOf(change.type) > -1)), filter(changes => changes.length > 0), keepUnstableUntilFirst);
+    }
+    /**
+     * Create a stream of changes as they occur it time. This method is similar to stateChanges()
+     * but it collects each event in an array over time.
+     */
+    auditTrail(events) {
+        return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));
+    }
+    /**
+     * Create a stream of synchronized changes. This method keeps the local array in sorted
+     * query order.
+     */
+    snapshotChanges(events) {
+        const validatedEvents = validateEventsArray(events);
+        const scheduledSortedChanges$ = sortedChanges(this.query, validatedEvents, this.afs.schedulers.outsideAngular);
+        return scheduledSortedChanges$.pipe(keepUnstableUntilFirst);
+    }
+    valueChanges(options = {}) {
+        const fromCollectionRefScheduled$ = fromCollectionRef(this.query, this.afs.schedulers.outsideAngular);
+        return fromCollectionRefScheduled$
+            .pipe(map(actions => actions.payload.docs.map(a => {
+            if (options.idField) {
+                return {
+                    [options.idField]: a.id,
+                    ...a.data()
+                };
+            }
+            else {
+                return a.data();
+            }
+        })), keepUnstableUntilFirst);
+    }
+    /**
+     * Retrieve the results of the query once.
+     */
+    get(options) {
+        return from(this.query.get(options)).pipe(keepUnstableUntilFirst);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-group.js","sourceRoot":"","sources":["../../../../../../src/compat/firestore/collection-group/collection-group.ts"],"names":[],"mappings":"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","sourcesContent":["import { from, Observable } from 'rxjs';\nimport { fromCollectionRef } from '../observable/fromRef';\nimport { filter, map, scan } from 'rxjs/operators';\nimport firebase from 'firebase/compat/app';\nimport { keepUnstableUntilFirst } from '@angular/fire';\n\nimport { DocumentChangeAction, DocumentChangeType, DocumentData, Query } from '../interfaces';\nimport { validateEventsArray } from '../collection/collection';\nimport { docChanges, sortedChanges } from '../collection/changes';\nimport { AngularFirestore } from '../firestore';\n\n/**\n * AngularFirestoreCollectionGroup service\n *\n * This class holds a reference to a Firestore Collection Group Query.\n *\n * This class uses Symbol.observable to transform into Observable using Observable.from().\n *\n * This class is rarely used directly and should be created from the AngularFirestore service.\n *\n * Example:\n *\n * const collectionGroup = firebase.firestore.collectionGroup('stocks');\n * const query = collectionRef.where('price', '>', '0.01');\n * const fakeStock = new AngularFirestoreCollectionGroup<Stock>(query, afs);\n *\n * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.\n * fakeStock.valueChanges().subscribe(value => console.log(value));\n */\nexport class AngularFirestoreCollectionGroup<T = DocumentData> {\n  /**\n   * The constructor takes in a CollectionGroupQuery to provide wrapper methods\n   * for data operations and data streaming.\n   */\n  constructor(\n    private readonly query: Query<T>,\n    private readonly afs: AngularFirestore) { }\n\n  /**\n   * Listen to the latest change in the stream. This method returns changes\n   * as they occur and they are not sorted by query order. This allows you to construct\n   * your own data structure.\n   */\n  stateChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    if (!events || events.length === 0) {\n      return docChanges<T>(this.query, this.afs.schedulers.outsideAngular).pipe(\n        keepUnstableUntilFirst\n      );\n    }\n    return docChanges<T>(this.query, this.afs.schedulers.outsideAngular)\n      .pipe(\n        map(actions => actions.filter(change => events.indexOf(change.type) > -1)),\n        filter(changes =>  changes.length > 0),\n        keepUnstableUntilFirst\n      );\n  }\n\n  /**\n   * Create a stream of changes as they occur it time. This method is similar to stateChanges()\n   * but it collects each event in an array over time.\n   */\n  auditTrail(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));\n  }\n\n  /**\n   * Create a stream of synchronized changes. This method keeps the local array in sorted\n   * query order.\n   */\n  snapshotChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    const validatedEvents = validateEventsArray(events);\n    const scheduledSortedChanges$ = sortedChanges<T>(this.query, validatedEvents, this.afs.schedulers.outsideAngular);\n    return scheduledSortedChanges$.pipe(\n      keepUnstableUntilFirst\n    );\n  }\n\n  /**\n   * Listen to all documents in the collection and its possible query as an Observable.\n   *\n   * If the `idField` option is provided, document IDs are included and mapped to the\n   * provided `idField` property name.\n   */\n  valueChanges(): Observable<T[]>;\n  // tslint:disable-next-line:unified-signatures\n  valueChanges({}): Observable<T[]>;\n  valueChanges<K extends string>(options: {idField: K}): Observable<(T & { [T in K]: string })[]>;\n  valueChanges<K extends string>(options: {idField?: K} = {}): Observable<T[]> {\n    const fromCollectionRefScheduled$ = fromCollectionRef<T>(this.query, this.afs.schedulers.outsideAngular);\n    return fromCollectionRefScheduled$\n      .pipe(\n        map(actions => actions.payload.docs.map(a => {\n          if (options.idField) {\n            return {\n              [options.idField]: a.id,\n              ...a.data()\n            } as T & { [T in K]: string };\n          } else {\n            return a.data();\n          }\n        })),\n        keepUnstableUntilFirst\n      );\n  }\n\n  /**\n   * Retrieve the results of the query once.\n   */\n  get(options?: firebase.firestore.GetOptions) {\n    return from(this.query.get(options)).pipe(\n      keepUnstableUntilFirst\n    );\n  }\n\n}\n"]}

package/esm2022/compat/firestore/document/document.mjs

@@ -0,0 +1,87 @@
+import { from } from 'rxjs';
+import { keepUnstableUntilFirst } from '@angular/fire';
+import { fromDocRef } from '../observable/fromRef';
+import { map } from 'rxjs/operators';
+import { associateQuery } from '../firestore';
+import { AngularFirestoreCollection } from '../collection/collection';
+/**
+ * AngularFirestoreDocument service
+ *
+ * This class creates a reference to a Firestore Document. A reference is provided in
+ * in the constructor. The class is generic which gives you type safety for data update
+ * methods and data streaming.
+ *
+ * This class uses Symbol.observable to transform into Observable using Observable.from().
+ *
+ * This class is rarely used directly and should be created from the AngularFirestore service.
+ *
+ * Example:
+ *
+ * const fakeStock = new AngularFirestoreDocument<Stock>(doc('stocks/FAKE'));
+ * await fakeStock.set({ name: 'FAKE', price: 0.01 });
+ * fakeStock.valueChanges().map(snap => {
+ *   if(snap.exists) return snap.data();
+ *   return null;
+ * }).subscribe(value => console.log(value));
+ * // OR! Transform using Observable.from() and the data is unwrapped for you
+ * Observable.from(fakeStock).subscribe(value => console.log(value));
+ */
+export class AngularFirestoreDocument {
+    ref;
+    afs;
+    /**
+     * The constructor takes in a DocumentReference to provide wrapper methods
+     * for data operations, data streaming, and Symbol.observable.
+     */
+    constructor(ref, afs) {
+        this.ref = ref;
+        this.afs = afs;
+    }
+    /**
+     * Create or overwrite a single document.
+     */
+    set(data, options) {
+        return this.ref.set(data, options);
+    }
+    /**
+     * Update some fields of a document without overwriting the entire document.
+     */
+    update(data) {
+        return this.ref.update(data);
+    }
+    /**
+     * Delete a document.
+     */
+    delete() {
+        return this.ref.delete();
+    }
+    /**
+     * Create a reference to a sub-collection given a path and an optional query
+     * function.
+     */
+    collection(path, queryFn) {
+        const collectionRef = this.ref.collection(path);
+        const { ref, query } = associateQuery(collectionRef, queryFn);
+        return new AngularFirestoreCollection(ref, query, this.afs);
+    }
+    /**
+     * Listen to snapshot updates from the document.
+     */
+    snapshotChanges() {
+        const scheduledFromDocRef$ = fromDocRef(this.ref, this.afs.schedulers.outsideAngular);
+        return scheduledFromDocRef$.pipe(keepUnstableUntilFirst);
+    }
+    valueChanges(options = {}) {
+        return this.snapshotChanges().pipe(map(({ payload }) => options.idField ? {
+            ...payload.data(),
+            ...{ [options.idField]: payload.id }
+        } : payload.data()));
+    }
+    /**
+     * Retrieve the document once.
+     */
+    get(options) {
+        return from(this.ref.get(options)).pipe(keepUnstableUntilFirst);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/firestore/firestore.mjs

@@ -0,0 +1,257 @@
+import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';
+import { from, of } from 'rxjs';
+import { AngularFirestoreDocument } from './document/document';
+import { AngularFirestoreCollection } from './collection/collection';
+import { AngularFirestoreCollectionGroup } from './collection-group/collection-group';
+import { ɵAngularFireSchedulers } from '@angular/fire';
+import { ɵfirebaseAppFactory, FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance } from '@angular/fire/compat';
+import { isPlatformServer } from '@angular/common';
+import 'firebase/compat/auth';
+import 'firebase/compat/firestore';
+import { AngularFireAuth, USE_EMULATOR as USE_AUTH_EMULATOR, SETTINGS as AUTH_SETTINGS, TENANT_ID, LANGUAGE_CODE, USE_DEVICE_LANGUAGE, PERSISTENCE, ɵauthFactory, } from '@angular/fire/compat/auth';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire";
+import * as i2 from "@angular/fire/compat/auth";
+import * as i3 from "@angular/fire/app-check";
+/**
+ * The value of this token determines whether or not the firestore will have persistance enabled
+ */
+export const ENABLE_PERSISTENCE = new InjectionToken('angularfire2.enableFirestorePersistence');
+export const PERSISTENCE_SETTINGS = new InjectionToken('angularfire2.firestore.persistenceSettings');
+export const SETTINGS = new InjectionToken('angularfire2.firestore.settings');
+export const USE_EMULATOR = new InjectionToken('angularfire2.firestore.use-emulator');
+/**
+ * A utility methods for associating a collection reference with
+ * a query.
+ *
+ * @param collectionRef - A collection reference to query
+ * @param queryFn - The callback to create a query
+ *
+ * Example:
+ * const { query, ref } = associateQuery(docRef.collection('items'), ref => {
+ *  return ref.where('age', '<', 200);
+ * });
+ */
+export function associateQuery(collectionRef, queryFn = ref => ref) {
+    const query = queryFn(collectionRef);
+    const ref = collectionRef;
+    return { query, ref };
+}
+/**
+ * AngularFirestore Service
+ *
+ * This service is the main entry point for this feature module. It provides
+ * an API for creating Collection and Reference services. These services can
+ * then be used to do data updates and observable streams of the data.
+ *
+ * Example:
+ *
+ * import { Component } from '@angular/core';
+ * import { AngularFirestore, AngularFirestoreCollection, AngularFirestoreDocument } from '@angular/fire/firestore';
+ * import { Observable } from 'rxjs/Observable';
+ * import { from } from 'rxjs/observable';
+ *
+ * @Component({
+ *   selector: 'app-my-component',
+ *   template: `
+ *    <h2>Items for {{ (profile | async)?.name }}
+ *    <ul>
+ *       <li *ngFor="let item of items | async">{{ item.name }}</li>
+ *    </ul>
+ *    <div class="control-input">
+ *       <input type="text" #itemname />
+ *       <button (click)="addItem(itemname.value)">Add Item</button>
+ *    </div>
+ *   `
+ * })
+ * export class MyComponent implements OnInit {
+ *
+ *   // services for data operations and data streaming
+ *   private readonly itemsRef: AngularFirestoreCollection<Item>;
+ *   private readonly profileRef: AngularFirestoreDocument<Profile>;
+ *
+ *   // observables for template
+ *   items: Observable<Item[]>;
+ *   profile: Observable<Profile>;
+ *
+ *   // inject main service
+ *   constructor(private readonly afs: AngularFirestore) {}
+ *
+ *   ngOnInit() {
+ *     this.itemsRef = afs.collection('items', ref => ref.where('user', '==', 'davideast').limit(10));
+ *     this.items = this.itemsRef.valueChanges().map(snap => snap.docs.map(data => doc.data()));
+ *     // this.items = from(this.itemsRef); // you can also do this with no mapping
+ *
+ *     this.profileRef = afs.doc('users/davideast');
+ *     this.profile = this.profileRef.valueChanges();
+ *   }
+ *
+ *   addItem(name: string) {
+ *     const user = 'davideast';
+ *     this.itemsRef.add({ name, user });
+ *   }
+ * }
+ */
+export class AngularFirestore {
+    schedulers;
+    firestore;
+    persistenceEnabled$;
+    /**
+     * Each Feature of AngularFire has a FirebaseApp injected. This way we
+     * don't rely on the main Firebase App instance and we can create named
+     * apps and use multiple apps.
+     */
+    constructor(options, name, shouldEnablePersistence, settings, 
+    // tslint:disable-next-line:ban-types
+    platformId, zone, schedulers, persistenceSettings, _useEmulator, auth, useAuthEmulator, authSettings, // can't use firebase.auth.AuthSettings here
+    tenantId, languageCode, useDeviceLanguage, persistence, _appCheckInstances) {
+        this.schedulers = schedulers;
+        const app = ɵfirebaseAppFactory(options, zone, name);
+        const useEmulator = _useEmulator;
+        if (auth) {
+            ɵauthFactory(app, zone, useAuthEmulator, tenantId, languageCode, useDeviceLanguage, authSettings, persistence);
+        }
+        [this.firestore, this.persistenceEnabled$] = ɵcacheInstance(`${app.name}.firestore`, 'AngularFirestore', app.name, () => {
+            const firestore = zone.runOutsideAngular(() => app.firestore());
+            if (settings) {
+                firestore.settings(settings);
+            }
+            if (useEmulator) {
+                firestore.useEmulator(...useEmulator);
+            }
+            if (shouldEnablePersistence && !isPlatformServer(platformId)) {
+                // We need to try/catch here because not all enablePersistence() failures are caught
+                // https://github.com/firebase/firebase-js-sdk/issues/608
+                const enablePersistence = () => {
+                    try {
+                        return from(firestore.enablePersistence(persistenceSettings || undefined).then(() => true, () => false));
+                    }
+                    catch (e) {
+                        if (typeof console !== 'undefined') {
+                            console.warn(e);
+                        }
+                        return of(false);
+                    }
+                };
+                return [firestore, zone.runOutsideAngular(enablePersistence)];
+            }
+            else {
+                return [firestore, of(false)];
+            }
+        }, [settings, useEmulator, shouldEnablePersistence]);
+    }
+    collection(pathOrRef, queryFn) {
+        let collectionRef;
+        if (typeof pathOrRef === 'string') {
+            collectionRef = this.firestore.collection(pathOrRef);
+        }
+        else {
+            collectionRef = pathOrRef;
+        }
+        const { ref, query } = associateQuery(collectionRef, queryFn);
+        const refInZone = this.schedulers.ngZone.run(() => ref);
+        return new AngularFirestoreCollection(refInZone, query, this);
+    }
+    /**
+     * Create a reference to a Firestore Collection Group based on a collectionId
+     * and an optional query function to narrow the result
+     * set.
+     */
+    collectionGroup(collectionId, queryGroupFn) {
+        const queryFn = queryGroupFn || (ref => ref);
+        const collectionGroup = this.firestore.collectionGroup(collectionId);
+        return new AngularFirestoreCollectionGroup(queryFn(collectionGroup), this);
+    }
+    doc(pathOrRef) {
+        let ref;
+        if (typeof pathOrRef === 'string') {
+            ref = this.firestore.doc(pathOrRef);
+        }
+        else {
+            ref = pathOrRef;
+        }
+        const refInZone = this.schedulers.ngZone.run(() => ref);
+        return new AngularFirestoreDocument(refInZone, this);
+    }
+    /**
+     * Returns a generated Firestore Document Id.
+     */
+    createId() {
+        return this.firestore.collection('_').doc().id;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestore, deps: [{ token: FIREBASE_OPTIONS }, { token: FIREBASE_APP_NAME, optional: true }, { token: ENABLE_PERSISTENCE, optional: true }, { token: SETTINGS, optional: true }, { token: PLATFORM_ID }, { token: i0.NgZone }, { token: i1.ɵAngularFireSchedulers }, { token: PERSISTENCE_SETTINGS, optional: true }, { token: USE_EMULATOR, optional: true }, { token: i2.AngularFireAuth, optional: true }, { token: USE_AUTH_EMULATOR, optional: true }, { token: AUTH_SETTINGS, optional: true }, { token: TENANT_ID, optional: true }, { token: LANGUAGE_CODE, optional: true }, { token: USE_DEVICE_LANGUAGE, optional: true }, { token: PERSISTENCE, optional: true }, { token: i3.AppCheckInstances, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestore, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FIREBASE_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FIREBASE_APP_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENABLE_PERSISTENCE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SETTINGS]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.NgZone }, { type: i1.ɵAngularFireSchedulers }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PERSISTENCE_SETTINGS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_EMULATOR]
+                }] }, { type: i2.AngularFireAuth, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_AUTH_EMULATOR]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTH_SETTINGS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TENANT_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LANGUAGE_CODE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_DEVICE_LANGUAGE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PERSISTENCE]
+                }] }, { type: i3.AppCheckInstances, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"firestore.js","sourceRoot":"","sources":["../../../../../src/compat/firestore/firestore.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';\nimport { from, Observable, of } from 'rxjs';\nimport {\n  AssociatedReference,\n  CollectionReference,\n  DocumentReference,\n  PersistenceSettings,\n  Query,\n  QueryFn,\n  QueryGroupFn,\n  Settings\n} from './interfaces';\nimport { AngularFirestoreDocument } from './document/document';\nimport { AngularFirestoreCollection } from './collection/collection';\nimport { AngularFirestoreCollectionGroup } from './collection-group/collection-group';\nimport { ɵAngularFireSchedulers } from '@angular/fire';\nimport { FirebaseApp, ɵfirebaseAppFactory, FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance } from '@angular/fire/compat';\nimport { FirebaseOptions } from 'firebase/app';\nimport { isPlatformServer } from '@angular/common';\nimport firebase from 'firebase/compat/app';\nimport 'firebase/compat/auth';\nimport 'firebase/compat/firestore';\nimport {\n  AngularFireAuth,\n  USE_EMULATOR as USE_AUTH_EMULATOR,\n  SETTINGS as AUTH_SETTINGS,\n  TENANT_ID,\n  LANGUAGE_CODE,\n  USE_DEVICE_LANGUAGE,\n  PERSISTENCE,\n  ɵauthFactory,\n} from '@angular/fire/compat/auth';\nimport { AppCheckInstances } from '@angular/fire/app-check';\n\n/**\n * The value of this token determines whether or not the firestore will have persistance enabled\n */\nexport const ENABLE_PERSISTENCE = new InjectionToken<boolean>('angularfire2.enableFirestorePersistence');\nexport const PERSISTENCE_SETTINGS = new InjectionToken<PersistenceSettings | undefined>('angularfire2.firestore.persistenceSettings');\nexport const SETTINGS = new InjectionToken<Settings>('angularfire2.firestore.settings');\n\ntype UseEmulatorArguments = Parameters<firebase.firestore.Firestore['useEmulator']>;\nexport const USE_EMULATOR = new InjectionToken<UseEmulatorArguments>('angularfire2.firestore.use-emulator');\n\n/**\n * A utility methods for associating a collection reference with\n * a query.\n *\n * @param collectionRef - A collection reference to query\n * @param queryFn - The callback to create a query\n *\n * Example:\n * const { query, ref } = associateQuery(docRef.collection('items'), ref => {\n *  return ref.where('age', '<', 200);\n * });\n */\nexport function associateQuery<T>(collectionRef: CollectionReference<T>, queryFn = ref => ref): AssociatedReference<T> {\n  const query = queryFn(collectionRef);\n  const ref = collectionRef;\n  return { query, ref };\n}\n\ntype InstanceCache = Map<FirebaseApp, [\n  firebase.firestore.Firestore,\n  firebase.firestore.Settings | null,\n  UseEmulatorArguments | null,\n  boolean | null]\n>;\n\n/**\n * AngularFirestore Service\n *\n * This service is the main entry point for this feature module. It provides\n * an API for creating Collection and Reference services. These services can\n * then be used to do data updates and observable streams of the data.\n *\n * Example:\n *\n * import { Component } from '@angular/core';\n * import { AngularFirestore, AngularFirestoreCollection, AngularFirestoreDocument } from '@angular/fire/firestore';\n * import { Observable } from 'rxjs/Observable';\n * import { from } from 'rxjs/observable';\n *\n * @Component({\n *   selector: 'app-my-component',\n *   template: `\n *    <h2>Items for {{ (profile | async)?.name }}\n *    <ul>\n *       <li *ngFor=\"let item of items | async\">{{ item.name }}</li>\n *    </ul>\n *    <div class=\"control-input\">\n *       <input type=\"text\" #itemname />\n *       <button (click)=\"addItem(itemname.value)\">Add Item</button>\n *    </div>\n *   `\n * })\n * export class MyComponent implements OnInit {\n *\n *   // services for data operations and data streaming\n *   private readonly itemsRef: AngularFirestoreCollection<Item>;\n *   private readonly profileRef: AngularFirestoreDocument<Profile>;\n *\n *   // observables for template\n *   items: Observable<Item[]>;\n *   profile: Observable<Profile>;\n *\n *   // inject main service\n *   constructor(private readonly afs: AngularFirestore) {}\n *\n *   ngOnInit() {\n *     this.itemsRef = afs.collection('items', ref => ref.where('user', '==', 'davideast').limit(10));\n *     this.items = this.itemsRef.valueChanges().map(snap => snap.docs.map(data => doc.data()));\n *     // this.items = from(this.itemsRef); // you can also do this with no mapping\n *\n *     this.profileRef = afs.doc('users/davideast');\n *     this.profile = this.profileRef.valueChanges();\n *   }\n *\n *   addItem(name: string) {\n *     const user = 'davideast';\n *     this.itemsRef.add({ name, user });\n *   }\n * }\n */\n@Injectable({\n  providedIn: 'any'\n})\nexport class AngularFirestore {\n  public readonly firestore: firebase.firestore.Firestore;\n  public readonly persistenceEnabled$: Observable<boolean>;\n\n  /**\n   * Each Feature of AngularFire has a FirebaseApp injected. This way we\n   * don't rely on the main Firebase App instance and we can create named\n   * apps and use multiple apps.\n   */\n  constructor(\n    @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,\n    @Optional() @Inject(FIREBASE_APP_NAME) name: string | null | undefined,\n    @Optional() @Inject(ENABLE_PERSISTENCE) shouldEnablePersistence: boolean | null,\n    @Optional() @Inject(SETTINGS) settings: Settings | null,\n    // tslint:disable-next-line:ban-types\n    @Inject(PLATFORM_ID) platformId: Object,\n    zone: NgZone,\n    public schedulers: ɵAngularFireSchedulers,\n    @Optional() @Inject(PERSISTENCE_SETTINGS) persistenceSettings: PersistenceSettings | null,\n    @Optional() @Inject(USE_EMULATOR) _useEmulator: any,\n    @Optional() auth: AngularFireAuth,\n    @Optional() @Inject(USE_AUTH_EMULATOR) useAuthEmulator: any,\n    @Optional() @Inject(AUTH_SETTINGS) authSettings: any, // can't use firebase.auth.AuthSettings here\n    @Optional() @Inject(TENANT_ID) tenantId: string | null,\n    @Optional() @Inject(LANGUAGE_CODE) languageCode: string | null,\n    @Optional() @Inject(USE_DEVICE_LANGUAGE) useDeviceLanguage: boolean | null,\n    @Optional() @Inject(PERSISTENCE) persistence: string | null,\n    @Optional() _appCheckInstances: AppCheckInstances,\n  ) {\n    const app = ɵfirebaseAppFactory(options, zone, name);\n    const useEmulator: UseEmulatorArguments | null = _useEmulator;\n\n    if (auth) {\n      ɵauthFactory(app, zone, useAuthEmulator, tenantId, languageCode, useDeviceLanguage, authSettings, persistence);\n    }\n\n    [this.firestore, this.persistenceEnabled$] = ɵcacheInstance(`${app.name}.firestore`, 'AngularFirestore', app.name, () => {\n      const firestore = zone.runOutsideAngular(() => app.firestore());\n      if (settings) {\n        firestore.settings(settings);\n      }\n      if (useEmulator) {\n        firestore.useEmulator(...useEmulator);\n      }\n\n      if (shouldEnablePersistence && !isPlatformServer(platformId)) {\n        // We need to try/catch here because not all enablePersistence() failures are caught\n        // https://github.com/firebase/firebase-js-sdk/issues/608\n        const enablePersistence = () => {\n          try {\n            return from(firestore.enablePersistence(persistenceSettings || undefined).then(() => true, () => false));\n          } catch (e) {\n            if (typeof console !== 'undefined') { console.warn(e); }\n            return of(false);\n          }\n        };\n        return [firestore, zone.runOutsideAngular(enablePersistence)];\n      } else {\n        return [firestore, of(false)];\n      }\n\n    }, [settings, useEmulator, shouldEnablePersistence]);\n  }\n\n  /**\n   * Create a reference to a Firestore Collection based on a path or\n   * CollectionReference and an optional query function to narrow the result\n   * set.\n   */\n  collection<T>(path: string, queryFn?: QueryFn): AngularFirestoreCollection<T>;\n  // tslint:disable-next-line:unified-signatures\n  collection<T>(ref: CollectionReference, queryFn?: QueryFn): AngularFirestoreCollection<T>;\n  collection<T>(pathOrRef: string | CollectionReference<T>, queryFn?: QueryFn): AngularFirestoreCollection<T> {\n    let collectionRef: CollectionReference<T>;\n    if (typeof pathOrRef === 'string') {\n      collectionRef = this.firestore.collection(pathOrRef) as firebase.firestore.CollectionReference<T>;\n    } else {\n      collectionRef = pathOrRef;\n    }\n    const { ref, query } = associateQuery<T>(collectionRef, queryFn);\n    const refInZone = this.schedulers.ngZone.run(() => ref);\n    return new AngularFirestoreCollection<T>(refInZone, query, this);\n  }\n\n  /**\n   * Create a reference to a Firestore Collection Group based on a collectionId\n   * and an optional query function to narrow the result\n   * set.\n   */\n  collectionGroup<T>(collectionId: string, queryGroupFn?: QueryGroupFn<T>): AngularFirestoreCollectionGroup<T> {\n    const queryFn = queryGroupFn || (ref => ref);\n    const collectionGroup: Query<T> = this.firestore.collectionGroup(collectionId) as firebase.firestore.Query<T>;\n    return new AngularFirestoreCollectionGroup<T>(queryFn(collectionGroup), this);\n  }\n\n  /**\n   * Create a reference to a Firestore Document based on a path or\n   * DocumentReference. Note that documents are not queryable because they are\n   * simply objects. However, documents have sub-collections that return a\n   * Collection reference and can be queried.\n   */\n  doc<T>(path: string): AngularFirestoreDocument<T>;\n  // tslint:disable-next-line:unified-signatures\n  doc<T>(ref: DocumentReference): AngularFirestoreDocument<T>;\n  doc<T>(pathOrRef: string | DocumentReference<T>): AngularFirestoreDocument<T> {\n    let ref: DocumentReference<T>;\n    if (typeof pathOrRef === 'string') {\n      ref = this.firestore.doc(pathOrRef) as firebase.firestore.DocumentReference<T>;\n    } else {\n      ref = pathOrRef;\n    }\n    const refInZone = this.schedulers.ngZone.run(() => ref);\n    return new AngularFirestoreDocument<T>(refInZone, this);\n  }\n\n  /**\n   * Returns a generated Firestore Document Id.\n   */\n  createId() {\n    return this.firestore.collection('_').doc().id;\n  }\n}\n"]}

package/{esm2015/compat/firestore/firestore.module.js → esm2022/compat/firestore/firestore.module.mjs}

@@ -19,14 +19,14 @@ export class AngularFirestoreModule {
             ]
         };
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestoreModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestoreModule, providers: [AngularFirestore] });
 }
-AngularFirestoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFirestoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFirestoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFirestoreModule });
-AngularFirestoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFirestoreModule, providers: [AngularFirestore] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFirestoreModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFirestoreModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [AngularFirestore]
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/firestore/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/firestore/observable/fromRef.mjs

@@ -0,0 +1,40 @@
+import { asyncScheduler, Observable } from 'rxjs';
+import { map, pairwise, startWith } from 'rxjs/operators';
+function _fromRef(ref, scheduler = asyncScheduler) {
+    return new Observable(subscriber => {
+        let unsubscribe;
+        if (scheduler != null) {
+            scheduler.schedule(() => {
+                unsubscribe = ref.onSnapshot({ includeMetadataChanges: true }, subscriber);
+            });
+        }
+        else {
+            unsubscribe = ref.onSnapshot({ includeMetadataChanges: true }, subscriber);
+        }
+        return () => {
+            if (unsubscribe != null) {
+                unsubscribe();
+            }
+        };
+    });
+}
+export function fromRef(ref, scheduler) {
+    return _fromRef(ref, scheduler);
+}
+export function fromDocRef(ref, scheduler) {
+    return fromRef(ref, scheduler)
+        .pipe(startWith(undefined), pairwise(), map((snapshots) => {
+        const [priorPayload, payload] = snapshots;
+        if (!payload.exists) {
+            return { payload, type: 'removed' };
+        }
+        if (!priorPayload?.exists) {
+            return { payload, type: 'added' };
+        }
+        return { payload, type: 'modified' };
+    }));
+}
+export function fromCollectionRef(ref, scheduler) {
+    return fromRef(ref, scheduler).pipe(map(payload => ({ payload, type: 'query' })));
+}
+//# sourceMappingURL=data:application/json;base64,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