@angular/fire 7.6.0 → 16.0.0-canary.1350920

package/esm2022/compat/firebase.app.module.mjs

@@ -0,0 +1,71 @@
+import { Inject, InjectionToken, VERSION as NG_VERSION, NgModule, NgZone, Optional, PLATFORM_ID, isDevMode } from '@angular/core';
+import { VERSION } from '@angular/fire';
+import firebase from 'firebase/compat/app';
+import { FirebaseApp } from './firebase.app';
+import * as i0 from "@angular/core";
+export const FIREBASE_OPTIONS = new InjectionToken('angularfire2.app.options');
+export const FIREBASE_APP_NAME = new InjectionToken('angularfire2.app.name');
+export function ɵfirebaseAppFactory(options, zone, nameOrConfig) {
+    const name = typeof nameOrConfig === 'string' && nameOrConfig || '[DEFAULT]';
+    const config = typeof nameOrConfig === 'object' && nameOrConfig || {};
+    config.name = config.name || name;
+    // Added any due to some inconsistency between @firebase/app and firebase types
+    const existingApp = firebase.apps.filter(app => app && app.name === config.name)[0];
+    // We support FirebaseConfig, initializeApp's public type only accepts string; need to cast as any
+    // Could be solved with https://github.com/firebase/firebase-js-sdk/pull/1206
+    const app = (existingApp || zone.runOutsideAngular(() => firebase.initializeApp(options, config)));
+    try {
+        if (JSON.stringify(options) !== JSON.stringify(app.options)) {
+            const hmr = !!module.hot;
+            log('error', `${app.name} Firebase App already initialized with different options${hmr ? ', you may need to reload as Firebase is not HMR aware.' : '.'}`);
+        }
+    }
+    catch (e) { /* empty */ }
+    return new FirebaseApp(app);
+}
+const log = (level, ...args) => {
+    if (isDevMode() && typeof console !== 'undefined') {
+        // eslint-disable-next-line no-console
+        console[level](...args);
+    }
+};
+const FIREBASE_APP_PROVIDER = {
+    provide: FirebaseApp,
+    useFactory: ɵfirebaseAppFactory,
+    deps: [
+        FIREBASE_OPTIONS,
+        NgZone,
+        [new Optional(), FIREBASE_APP_NAME]
+    ]
+};
+export class AngularFireModule {
+    static initializeApp(options, nameOrConfig) {
+        return {
+            ngModule: AngularFireModule,
+            providers: [
+                { provide: FIREBASE_OPTIONS, useValue: options },
+                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig }
+            ]
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    constructor(platformId) {
+        firebase.registerVersion('angularfire', VERSION.full, 'core');
+        firebase.registerVersion('angularfire', VERSION.full, 'app-compat');
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        firebase.registerVersion('angular', NG_VERSION.full, platformId.toString());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: AngularFireModule, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.10", ngImport: i0, type: AngularFireModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: AngularFireModule, providers: [FIREBASE_APP_PROVIDER] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.10", ngImport: i0, type: AngularFireModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [FIREBASE_APP_PROVIDER]
+                }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/firestore/collection/changes.mjs

@@ -0,0 +1,108 @@
+import { distinctUntilChanged, map, pairwise, scan, startWith } from 'rxjs/operators';
+import { fromCollectionRef } from '../observable/fromRef';
+/**
+ * Return a stream of document changes on a query. These results are not in sort order but in
+ * order of occurence.
+ */
+export function docChanges(query, scheduler) {
+    return fromCollectionRef(query, scheduler)
+        .pipe(startWith(undefined), pairwise(), map((actionTuple) => {
+        const [priorAction, action] = actionTuple;
+        const docChanges = action.payload.docChanges();
+        const actions = docChanges.map(change => ({ type: change.type, payload: change }));
+        // the metadata has changed from the prior emission
+        if (priorAction && JSON.stringify(priorAction.payload.metadata) !== JSON.stringify(action.payload.metadata)) {
+            // go through all the docs in payload and figure out which ones changed
+            action.payload.docs.forEach((currentDoc, currentIndex) => {
+                const docChange = docChanges.find(d => d.doc.ref.isEqual(currentDoc.ref));
+                const priorDoc = priorAction?.payload.docs.find(d => d.ref.isEqual(currentDoc.ref));
+                if (docChange && JSON.stringify(docChange.doc.metadata) === JSON.stringify(currentDoc.metadata) ||
+                    !docChange && priorDoc && JSON.stringify(priorDoc.metadata) === JSON.stringify(currentDoc.metadata)) {
+                    // document doesn't appear to have changed, don't log another action
+                }
+                else {
+                    // since the actions are processed in order just push onto the array
+                    actions.push({
+                        type: 'modified',
+                        payload: {
+                            oldIndex: currentIndex,
+                            newIndex: currentIndex,
+                            type: 'modified',
+                            doc: currentDoc
+                        }
+                    });
+                }
+            });
+        }
+        return actions;
+    }));
+}
+/**
+ * Return a stream of document changes on a query. These results are in sort order.
+ */
+export function sortedChanges(query, events, scheduler) {
+    return docChanges(query, scheduler)
+        .pipe(scan((current, changes) => combineChanges(current, changes.map(it => it.payload), events), []), distinctUntilChanged(), // cut down on unneed change cycles
+    map(changes => changes.map(c => ({ type: c.type, payload: c }))));
+}
+/**
+ * Combines the total result set from the current set of changes from an incoming set
+ * of changes.
+ */
+export function combineChanges(current, changes, events) {
+    changes.forEach(change => {
+        // skip unwanted change types
+        if (events.indexOf(change.type) > -1) {
+            current = combineChange(current, change);
+        }
+    });
+    return current;
+}
+/**
+ * Splice arguments on top of a sliced array, to break top-level ===
+ * this is useful for change-detection
+ */
+function sliceAndSplice(original, start, deleteCount, ...args) {
+    const returnArray = original.slice();
+    returnArray.splice(start, deleteCount, ...args);
+    return returnArray;
+}
+/**
+ * Creates a new sorted array from a new change.
+ * Build our own because we allow filtering of action types ('added', 'removed', 'modified') before scanning
+ * and so we have greater control over change detection (by breaking ===)
+ */
+export function combineChange(combined, change) {
+    switch (change.type) {
+        case 'added':
+            if (combined[change.newIndex] && combined[change.newIndex].doc.ref.isEqual(change.doc.ref)) {
+                // Not sure why the duplicates are getting fired
+            }
+            else {
+                return sliceAndSplice(combined, change.newIndex, 0, change);
+            }
+            break;
+        case 'modified':
+            if (combined[change.oldIndex] == null || combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {
+                // When an item changes position we first remove it
+                // and then add it's new position
+                if (change.oldIndex !== change.newIndex) {
+                    const copiedArray = combined.slice();
+                    copiedArray.splice(change.oldIndex, 1);
+                    copiedArray.splice(change.newIndex, 0, change);
+                    return copiedArray;
+                }
+                else {
+                    return sliceAndSplice(combined, change.newIndex, 1, change);
+                }
+            }
+            break;
+        case 'removed':
+            if (combined[change.oldIndex] && combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {
+                return sliceAndSplice(combined, change.oldIndex, 1);
+            }
+            break;
+    }
+    return combined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"changes.js","sourceRoot":"","sources":["../../../../../../src/compat/firestore/collection/changes.ts"],"names":[],"mappings":"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","sourcesContent":["import firebase from 'firebase/compat/app';\nimport { Observable, SchedulerLike } from 'rxjs';\nimport { distinctUntilChanged, map, pairwise, scan, startWith } from 'rxjs/operators';\nimport { Action, DocumentChange, DocumentChangeAction, DocumentChangeType, Query, QuerySnapshot } from '../interfaces';\nimport { fromCollectionRef } from '../observable/fromRef';\n\n\ntype ActionTupe = [Action<QuerySnapshot<firebase.firestore.DocumentData>>, Action<QuerySnapshot<firebase.firestore.DocumentData>>]\n/**\n * Return a stream of document changes on a query. These results are not in sort order but in\n * order of occurence.\n */\nexport function docChanges<T>(query: Query, scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]> {\n  return fromCollectionRef(query, scheduler)\n    .pipe(\n      startWith<Action<QuerySnapshot<firebase.firestore.DocumentData>>, undefined>(undefined),\n      pairwise(),\n      map((actionTuple: ActionTupe) => {\n        const [priorAction, action] = actionTuple;\n        const docChanges = action.payload.docChanges();\n        const actions = docChanges.map(change => ({ type: change.type, payload: change }));\n        // the metadata has changed from the prior emission\n        if (priorAction && JSON.stringify(priorAction.payload.metadata) !== JSON.stringify(action.payload.metadata)) {\n          // go through all the docs in payload and figure out which ones changed\n          action.payload.docs.forEach((currentDoc, currentIndex) => {\n            const docChange = docChanges.find(d => d.doc.ref.isEqual(currentDoc.ref));\n            const priorDoc = priorAction?.payload.docs.find(d => d.ref.isEqual(currentDoc.ref));\n            if (docChange && JSON.stringify(docChange.doc.metadata) === JSON.stringify(currentDoc.metadata) ||\n              !docChange && priorDoc && JSON.stringify(priorDoc.metadata) === JSON.stringify(currentDoc.metadata)) {\n              // document doesn't appear to have changed, don't log another action\n            } else {\n              // since the actions are processed in order just push onto the array\n              actions.push({\n                type: 'modified',\n                payload: {\n                  oldIndex: currentIndex,\n                  newIndex: currentIndex,\n                  type: 'modified',\n                  doc: currentDoc\n                }\n              });\n            }\n          });\n        }\n        return actions as DocumentChangeAction<T>[];\n      }),\n  );\n}\n\n/**\n * Return a stream of document changes on a query. These results are in sort order.\n */\nexport function sortedChanges<T>(\n  query: Query,\n  events: DocumentChangeType[],\n  scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]> {\n  return docChanges<T>(query, scheduler)\n    .pipe(\n      scan((current, changes) => combineChanges<T>(current, changes.map(it => it.payload), events), []),\n      distinctUntilChanged(), // cut down on unneed change cycles\n      map(changes => changes.map(c => ({ type: c.type, payload: c } as DocumentChangeAction<T>))));\n}\n\n/**\n * Combines the total result set from the current set of changes from an incoming set\n * of changes.\n */\nexport function combineChanges<T>(current: DocumentChange<T>[], changes: DocumentChange<T>[], events: DocumentChangeType[]) {\n  changes.forEach(change => {\n    // skip unwanted change types\n    if (events.indexOf(change.type) > -1) {\n      current = combineChange(current, change);\n    }\n  });\n  return current;\n}\n\n/**\n * Splice arguments on top of a sliced array, to break top-level ===\n * this is useful for change-detection\n */\nfunction sliceAndSplice<T>(\n  original: T[],\n  start: number,\n  deleteCount: number,\n  ...args: T[]\n): T[] {\n  const returnArray = original.slice();\n  returnArray.splice(start, deleteCount, ...args);\n  return returnArray;\n}\n\n/**\n * Creates a new sorted array from a new change.\n * Build our own because we allow filtering of action types ('added', 'removed', 'modified') before scanning\n * and so we have greater control over change detection (by breaking ===)\n */\nexport function combineChange<T>(combined: DocumentChange<T>[], change: DocumentChange<T>): DocumentChange<T>[] {\n  switch (change.type) {\n    case 'added':\n      if (combined[change.newIndex] && combined[change.newIndex].doc.ref.isEqual(change.doc.ref)) {\n        // Not sure why the duplicates are getting fired\n      } else {\n        return sliceAndSplice(combined, change.newIndex, 0, change);\n      }\n      break;\n    case 'modified':\n      if (combined[change.oldIndex] == null || combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {\n        // When an item changes position we first remove it\n        // and then add it's new position\n        if (change.oldIndex !== change.newIndex) {\n          const copiedArray = combined.slice();\n          copiedArray.splice(change.oldIndex, 1);\n          copiedArray.splice(change.newIndex, 0, change);\n          return copiedArray;\n        } else {\n          return sliceAndSplice(combined, change.newIndex, 1, change);\n        }\n      }\n      break;\n    case 'removed':\n      if (combined[change.oldIndex] && combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {\n        return sliceAndSplice(combined, change.oldIndex, 1);\n      }\n      break;\n  }\n  return combined;\n}\n"]}

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

@@ -0,0 +1,123 @@
+import { keepUnstableUntilFirst } from '@angular/fire';
+import { from } from 'rxjs';
+import { filter, map, pairwise, scan, startWith } from 'rxjs/operators';
+import { AngularFirestoreDocument } from '../document/document';
+import { fromCollectionRef } from '../observable/fromRef';
+import { docChanges, sortedChanges } from './changes';
+export function validateEventsArray(events) {
+    if (!events || events.length === 0) {
+        events = ['added', 'removed', 'modified'];
+    }
+    return events;
+}
+/**
+ * AngularFirestoreCollection service
+ *
+ * This class creates a reference to a Firestore Collection. A reference and a query are provided in
+ * in the constructor. The query can be the unqueried reference if no query is desired.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 collectionRef = firebase.firestore.collection('stocks');
+ * const query = collectionRef.where('price', '>', '0.01');
+ * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);
+ *
+ * // NOTE!: the updates are performed on the reference not the query
+ * await fakeStock.add({ name: 'FAKE', price: 0.01 });
+ *
+ * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.
+ * fakeStock.valueChanges().subscribe(value => console.log(value));
+ */
+export class AngularFirestoreCollection {
+    ref;
+    query;
+    afs;
+    /**
+     * The constructor takes in a CollectionReference and Query to provide wrapper methods
+     * for data operations and data streaming.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query. See the AssociatedRefence type for details
+     * on this implication.
+     */
+    constructor(ref, query, afs) {
+        this.ref = ref;
+        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) {
+        let source = docChanges(this.query, this.afs.schedulers.outsideAngular);
+        if (events && events.length > 0) {
+            source = source.pipe(map(actions => actions.filter(change => events.indexOf(change.type) > -1)));
+        }
+        return source.pipe(
+        // We want to filter out empty arrays, but always emit at first, so the developer knows
+        // that the collection has been resolve; even if it's empty
+        startWith(undefined), pairwise(), filter(([prior, current]) => current.length > 0 || !prior), map(([, current]) => current), 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 = {}) {
+        return fromCollectionRef(this.query, this.afs.schedulers.outsideAngular)
+            .pipe(map(actions => actions.payload.docs.map(a => {
+            if (options.idField) {
+                return {
+                    ...a.data(),
+                    ...{ [options.idField]: a.id }
+                };
+            }
+            else {
+                return a.data();
+            }
+        })), keepUnstableUntilFirst);
+    }
+    /**
+     * Retrieve the results of the query once.
+     */
+    get(options) {
+        return from(this.query.get(options)).pipe(keepUnstableUntilFirst);
+    }
+    /**
+     * Add data to a collection reference.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query.
+     */
+    add(data) {
+        return this.ref.add(data);
+    }
+    /**
+     * Create a reference to a single document in a collection.
+     */
+    doc(path) {
+        // TODO is there a better way to solve this type issue
+        return new AngularFirestoreDocument(this.ref.doc(path), this.afs);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../../../../src/compat/firestore/collection/collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { keepUnstableUntilFirst } from '@angular/fire';\nimport firebase from 'firebase/compat/app';\nimport { Observable, from } from 'rxjs';\nimport { filter, map, pairwise, scan, startWith } from 'rxjs/operators';\nimport { AngularFirestoreDocument } from '../document/document';\nimport { AngularFirestore } from '../firestore';\nimport { CollectionReference, DocumentChangeAction, DocumentChangeType, DocumentData, DocumentReference, Query } from '../interfaces';\nimport { fromCollectionRef } from '../observable/fromRef';\nimport { docChanges, sortedChanges } from './changes';\n\ntype DocumentChangeTuple<T> = [DocumentChangeAction<T>[], DocumentChangeAction<T>[]];\n\nexport function validateEventsArray(events?: DocumentChangeType[]) {\n  if (!events || events.length === 0) {\n    events = ['added', 'removed', 'modified'];\n  }\n  return events;\n}\n\n/**\n * AngularFirestoreCollection service\n *\n * This class creates a reference to a Firestore Collection. A reference and a query are provided in\n * in the constructor. The query can be the unqueried reference if no query is desired.The class\n * is generic which gives you type safety for data update methods and data streaming.\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 collectionRef = firebase.firestore.collection('stocks');\n * const query = collectionRef.where('price', '>', '0.01');\n * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);\n *\n * // NOTE!: the updates are performed on the reference not the query\n * await fakeStock.add({ name: 'FAKE', price: 0.01 });\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 AngularFirestoreCollection<T = DocumentData> {\n  /**\n   * The constructor takes in a CollectionReference and Query to provide wrapper methods\n   * for data operations and data streaming.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query. See the AssociatedRefence type for details\n   * on this implication.\n   */\n  constructor(\n    public readonly ref: CollectionReference<T>,\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    let source = docChanges<T>(this.query, this.afs.schedulers.outsideAngular);\n    if (events && events.length > 0) {\n      source = source.pipe(\n        map(actions => actions.filter(change => events.indexOf(change.type) > -1))\n      );\n    }\n    return source.pipe(\n      // We want to filter out empty arrays, but always emit at first, so the developer knows\n      // that the collection has been resolve; even if it's empty\n      startWith<DocumentChangeAction<T>[], undefined>(undefined),\n      pairwise(),\n      filter(([prior, current]: DocumentChangeTuple<T>) => current.length > 0 || !prior),\n      map(([, current]) => current),\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  // eslint-disable-next-line no-empty-pattern\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    return fromCollectionRef<T>(this.query, this.afs.schedulers.outsideAngular)\n      .pipe(\n        map(actions => actions.payload.docs.map(a => {\n          if (options.idField) {\n            return {\n              ...a.data() as any,\n              ...{ [options.idField]: a.id }\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   * Add data to a collection reference.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query.\n   */\n  add(data: T): Promise<DocumentReference<T>> {\n    return this.ref.add(data);\n  }\n\n  /**\n   * Create a reference to a single document in a collection.\n   */\n  doc<T2 = T>(path?: string): AngularFirestoreDocument<T2> {\n    // TODO is there a better way to solve this type issue\n    return new AngularFirestoreDocument(this.ref.doc(path) as any, this.afs);\n  }\n}\n"]}

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

@@ -0,0 +1,86 @@
+import { keepUnstableUntilFirst } from '@angular/fire';
+import { from } from 'rxjs';
+import { filter, map, scan } from 'rxjs/operators';
+import { docChanges, sortedChanges } from '../collection/changes';
+import { validateEventsArray } from '../collection/collection';
+import { fromCollectionRef } from '../observable/fromRef';
+/**
+ * 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 { keepUnstableUntilFirst } from '@angular/fire';\nimport firebase from 'firebase/compat/app';\nimport { Observable, from } from 'rxjs';\nimport { filter, map, scan } from 'rxjs/operators';\nimport { docChanges, sortedChanges } from '../collection/changes';\nimport { validateEventsArray } from '../collection/collection';\nimport { AngularFirestore } from '../firestore';\nimport { DocumentChangeAction, DocumentChangeType, DocumentData, Query } from '../interfaces';\nimport { fromCollectionRef } from '../observable/fromRef';\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  // eslint-disable-next-line no-empty-pattern\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 { keepUnstableUntilFirst } from '@angular/fire';
+import { from } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AngularFirestoreCollection } from '../collection/collection';
+import { associateQuery } from '../firestore';
+import { fromDocRef } from '../observable/fromRef';
+/**
+ * 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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