@angular/fire
Version:
The official Angular library for Firebase.
254 lines • 31.4 kB
JavaScript
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 {
/**
* 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;
}
}
AngularFirestore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.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 });
AngularFirestore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFirestore, providedIn: 'any' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.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":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAClG,OAAO,EAAE,IAAI,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AAW5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,+BAA+B,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAe,mBAAmB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE7H,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,sBAAsB,CAAC;AAC9B,OAAO,2BAA2B,CAAC;AACnC,OAAO,EACL,eAAe,EACf,YAAY,IAAI,iBAAiB,EACjC,QAAQ,IAAI,aAAa,EACzB,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;;;;;AAE5D;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,cAAc,CAAU,yCAAyC,CAAC,CAAC;AACzG,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,cAAc,CAAkC,4CAA4C,CAAC,CAAC;AACtI,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,cAAc,CAAW,iCAAiC,CAAC,CAAC;AAGxF,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAAuB,qCAAqC,CAAC,CAAC;AAE5G;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAI,aAAqC,EAAE,OAAO,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG;IAC3F,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC,MAAM,GAAG,GAAG,aAAa,CAAC;IAC1B,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;AACxB,CAAC;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAIH,MAAM,OAAO,gBAAgB;IAI3B;;;;OAIG;IACH,YAC4B,OAAwB,EACX,IAA+B,EAC9B,uBAAuC,EACjD,QAAyB;IACvD,qCAAqC;IAChB,UAAkB,EACvC,IAAY,EACL,UAAkC,EACC,mBAA+C,EACvD,YAAiB,EACvC,IAAqB,EACM,eAAoB,EACxB,YAAiB,EAAE,4CAA4C;IACnE,QAAuB,EACnB,YAA2B,EACrB,iBAAiC,EACzC,WAA0B,EAC/C,kBAAqC;QAV1C,eAAU,GAAV,UAAU,CAAwB;QAYzC,MAAM,GAAG,GAAG,mBAAmB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,WAAW,GAAgC,YAAY,CAAC;QAE9D,IAAI,IAAI,EAAE;YACR,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC;SAChH;QAED,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG,cAAc,CAAC,GAAG,GAAG,CAAC,IAAI,YAAY,EAAE,kBAAkB,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE;YACtH,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;YAChE,IAAI,QAAQ,EAAE;gBACZ,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;aAC9B;YACD,IAAI,WAAW,EAAE;gBACf,SAAS,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,CAAC;aACvC;YAED,IAAI,uBAAuB,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE;gBAC5D,oFAAoF;gBACpF,yDAAyD;gBACzD,MAAM,iBAAiB,GAAG,GAAG,EAAE;oBAC7B,IAAI;wBACF,OAAO,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,mBAAmB,IAAI,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;qBAC1G;oBAAC,OAAO,CAAC,EAAE;wBACV,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE;4BAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;yBAAE;wBACxD,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;qBAClB;gBACH,CAAC,CAAC;gBACF,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,CAAC;aAC/D;iBAAM;gBACL,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;aAC/B;QAEH,CAAC,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,uBAAuB,CAAC,CAAC,CAAC;IACvD,CAAC;IAUD,UAAU,CAAI,SAA0C,EAAE,OAAiB;QACzE,IAAI,aAAqC,CAAC;QAC1C,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;YACjC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,CAA8C,CAAC;SACnG;aAAM;YACL,aAAa,GAAG,SAAS,CAAC;SAC3B;QACD,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,cAAc,CAAI,aAAa,EAAE,OAAO,CAAC,CAAC;QACjE,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QACxD,OAAO,IAAI,0BAA0B,CAAI,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAI,YAAoB,EAAE,YAA8B;QACrE,MAAM,OAAO,GAAG,YAAY,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC7C,MAAM,eAAe,GAAa,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,YAAY,CAAgC,CAAC;QAC9G,OAAO,IAAI,+BAA+B,CAAI,OAAO,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC,CAAC;IAChF,CAAC;IAWD,GAAG,CAAI,SAAwC;QAC7C,IAAI,GAAyB,CAAC;QAC9B,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE;YACjC,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAA4C,CAAC;SAChF;aAAM;YACL,GAAG,GAAG,SAAS,CAAC;SACjB;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QACxD,OAAO,IAAI,wBAAwB,CAAI,SAAS,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;IACjD,CAAC;;6GAxHU,gBAAgB,kBAUjB,gBAAgB,aACJ,iBAAiB,6BACjB,kBAAkB,6BAClB,QAAQ,6BAEpB,WAAW,yEAGC,oBAAoB,6BACpB,YAAY,4EAEZ,iBAAiB,6BACjB,aAAa,6BACb,SAAS,6BACT,aAAa,6BACb,mBAAmB,6BACnB,WAAW;iHA1BtB,gBAAgB,cAFf,KAAK;2FAEN,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,KAAK;iBAClB;;0BAWI,MAAM;2BAAC,gBAAgB;;0BACvB,QAAQ;;0BAAI,MAAM;2BAAC,iBAAiB;;0BACpC,QAAQ;;0BAAI,MAAM;2BAAC,kBAAkB;;0BACrC,QAAQ;;0BAAI,MAAM;2BAAC,QAAQ;8BAEK,MAAM;0BAAtC,MAAM;2BAAC,WAAW;;0BAGlB,QAAQ;;0BAAI,MAAM;2BAAC,oBAAoB;;0BACvC,QAAQ;;0BAAI,MAAM;2BAAC,YAAY;;0BAC/B,QAAQ;;0BACR,QAAQ;;0BAAI,MAAM;2BAAC,iBAAiB;;0BACpC,QAAQ;;0BAAI,MAAM;2BAAC,aAAa;;0BAChC,QAAQ;;0BAAI,MAAM;2BAAC,SAAS;;0BAC5B,QAAQ;;0BAAI,MAAM;2BAAC,aAAa;;0BAChC,QAAQ;;0BAAI,MAAM;2BAAC,mBAAmB;;0BACtC,QAAQ;;0BAAI,MAAM;2BAAC,WAAW;;0BAC9B,QAAQ","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"]}