Cleaning things up

Author: jamesdaniels

sample/src/app/app.component.ts

@@ -1,10 +1,9 @@
-import { ApplicationRef, Component, Inject, NgZone, Optional } from '@angular/core';
-import { FirebaseApp, Auth, FirebaseApps, AuthInstances, FunctionsInstances,
-  Functions, FirestoreInstances, Firestore } from '@angular/fire';
-import { authState } from '@angular/fire/auth';
-import { debounceTime, distinct } from 'rxjs/operators';
-import { getApps } from '@firebase/app';
-import { Observable } from 'rxjs';
+import { ApplicationRef, Component, NgZone } from '@angular/core';
+import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
+import { Auth, AuthInstances, authState } from '@angular/fire/auth';
+import { Firestore, FirestoreInstances } from '@angular/fire/firestore';
+import { functionInstance$ } from '@angular/fire/functions';
+import { debounceTime } from 'rxjs/operators';
 
 @Component({
   selector: 'app-root',
@@ -36,18 +35,16 @@ import { Observable } from 'rxjs';
 export class AppComponent {
   title = 'sample';
   constructor(
-    public app: FirebaseApp,      // default Firebase App
+    public app: FirebaseApp, // default Firebase App
     public auth: Auth, // default Firbase Auth
     public apps: FirebaseApps, // all initialized App instances
     public authInstances: AuthInstances, // all initialized Auth instances
-    public functions: Functions,
-    public functionsInstances: FunctionsInstances,
     public firestore: Firestore,
     public firestoreInstances: FirestoreInstances,
     appRef: ApplicationRef,
     zone: NgZone,
   ) {
-    console.log({app, auth, apps, authInstances, functions, functionsInstances, firestore, firestoreInstances});
+    console.log({app, auth, apps, authInstances, firestore, firestoreInstances });
     // onAuthStateChanged should destablize the zone
     // onAuthStateChanged(auth, it => console.log('onAuthStateChanged', it));
     authState(auth).subscribe(it => console.log('authState', it));
@@ -63,5 +60,6 @@ export class AppComponent {
         functions.getFunctions(app, 'asdf');
       }, 10000);
     });
+    functionInstance$.subscribe(it => console.log('$', it));
   }
 }

sample/src/app/app.module.ts

@@ -1,13 +1,14 @@
 import { NgModule } from '@angular/core';
 import { BrowserModule } from '@angular/platform-browser';
-import { provideFirebaseApp, provideAuth, FirestoreModule } from '@angular/fire';
+import { provideFirebaseApp } from '@angular/fire/app';
+import { provideAuth } from '@angular/fire/auth';
 import { initializeApp, getApp } from 'firebase/app';
-import { initializeAuth, getAuth } from '@firebase/auth';
-
+import { initializeAuth } from 'firebase/auth';
 import { AppRoutingModule } from './app-routing.module';
 import { AppComponent } from './app.component';
 import { environment } from '../environments/environment';
-import { FunctionsModule  } from '@angular/fire';
+import { initializeFirestore } from 'firebase/firestore';
+import { provideFirestore } from '@angular/fire/firestore';
 
 @NgModule({
   declarations: [
@@ -22,14 +23,8 @@ import { FunctionsModule  } from '@angular/fire';
       app.automaticDataCollectionEnabled = false;
       return app;
     }),
-    provideAuth(() => getAuth()),
-    provideAuth(() => {
-      const auth = initializeAuth(getApp('second'));
-      auth.useDeviceLanguage();
-      return auth;
-    }),
-    FunctionsModule,
-    FirestoreModule,
+    provideAuth(() => initializeAuth(getApp())),
+    provideFirestore(() => initializeFirestore(getApp(), {}))
   ],
   providers: [ ],
   bootstrap: [AppComponent]

src/analytics/analytics.module.ts

@@ -1,26 +1,24 @@
 import { NgModule, Optional, NgZone, InjectionToken, ModuleWithProviders } from '@angular/core';
-import { Analytics as FirebaseAnalytics } from 'firebase/analytics';
-import { ɵgetDefaultInstanceOf, ɵmemoizeInstance } from '../core';
+import { Analytics as FirebaseAnalytics, initializeAnalytics } from 'firebase/analytics';
+import { ɵgetDefaultInstanceOf, ɵmemoizeInstance, ɵAngularFireSchedulers } from '@angular/fire';
 import { Analytics, ANALYTICS_PROVIDER_NAME, AnalyticsInstances } from './analytics';
-import { PROVIDED_FIREBASE_APPS } from '../app/app.module';
-import { ɵAngularFireSchedulers } from '../zones';
+import { getApp } from 'firebase/app';
+import { FirebaseApps } from '@angular/fire/app';
 
 export const PROVIDED_ANALYTICS_INSTANCES = new InjectionToken<Analytics[]>('angularfire2.analytics-instances');
 
-export function ɵdefaultAnalyticsInstanceFactory(_: Analytics[]) {
-  const defaultAnalytics = ɵgetDefaultInstanceOf<FirebaseAnalytics>(ANALYTICS_PROVIDER_NAME);
+export function defaultAnalyticsInstanceFactory(_: Analytics[]) {
+  const defaultAnalytics = ɵgetDefaultInstanceOf<FirebaseAnalytics>(ANALYTICS_PROVIDER_NAME) || initializeAnalytics(getApp());
   return new Analytics(defaultAnalytics);
 }
 
-// Hack: useFactory doesn't allow us to pass a lambda, so let's bind the arugments
-// Going this direction to cut down on DI token noise; also making it easier to support
-// multiple Firebase Apps
-export function ɵboundAnalyticsInstanceFactory(zone: NgZone) {
-  const analytics = ɵmemoizeInstance<FirebaseAnalytics>(this, zone);
-  return new Analytics(analytics);
+export function analyticsInstanceFactory(fn: () => FirebaseAnalytics) {
+  return (zone: NgZone) => {
+    const analytics = ɵmemoizeInstance<FirebaseAnalytics>(fn, zone);
+    return new Analytics(analytics);
+  };
 }
 
-
 const ANALYTICS_INSTANCES_PROVIDER = {
   provide: AnalyticsInstances,
   deps: [
@@ -30,7 +28,7 @@ const ANALYTICS_INSTANCES_PROVIDER = {
 
 const DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
   provide: Analytics,
-  useFactory: ɵdefaultAnalyticsInstanceFactory,
+  useFactory: defaultAnalyticsInstanceFactory,
   deps: [
     NgZone,
     [new Optional(), PROVIDED_ANALYTICS_INSTANCES ],
@@ -43,20 +41,20 @@ const DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
     ANALYTICS_INSTANCES_PROVIDER,
   ]
 })
-export class AngularFireAnalyticsModule {
+export class AnalyticsModule {
 }
 
-export function provideAnalytics(fn: () => FirebaseAnalytics): ModuleWithProviders<AngularFireAnalyticsModule> {
+export function provideAnalytics(fn: () => FirebaseAnalytics): ModuleWithProviders<AnalyticsModule> {
   return {
-    ngModule: AngularFireAnalyticsModule,
+    ngModule: AnalyticsModule,
     providers: [{
       provide: PROVIDED_ANALYTICS_INSTANCES,
-      useFactory: ɵboundAnalyticsInstanceFactory.bind(fn),
+      useFactory: analyticsInstanceFactory(fn),
       multi: true,
       deps: [
         NgZone,
         ɵAngularFireSchedulers,
-        [new Optional(), PROVIDED_FIREBASE_APPS ]
+        FirebaseApps,
       ]
     }]
   };

src/analytics/analytics.ts

@@ -1,5 +1,7 @@
 import { Analytics as FirebaseAnalytics } from 'firebase/analytics';
-import { ɵgetAllInstancesOf } from '../core';
+import { ɵgetAllInstancesOf } from '@angular/fire';
+import { from, timer } from 'rxjs';
+import { concatMap, distinct, switchMap } from 'rxjs/operators';
 
 // see notes in core/firebase.app.module.ts for why we're building the class like this
 // tslint:disable-next-line:no-empty-interface
@@ -21,3 +23,8 @@ export class AnalyticsInstances {
     return ɵgetAllInstancesOf<FirebaseAnalytics>(ANALYTICS_PROVIDER_NAME);
   }
 }
+
+export const analyticInstance$ = timer(0, 300).pipe(
+  concatMap(() => from(ɵgetAllInstancesOf<FirebaseAnalytics>(ANALYTICS_PROVIDER_NAME))),
+  distinct(),
+);

src/analytics/public_api.ts

@@ -1 +1,2 @@
-export { Analytics, provideAnalytics, AnalyticsInstances } from '@angular/fire';
+export { Analytics, AnalyticsInstances, analyticInstance$ } from './analytics';
+export { provideAnalytics, AnalyticsModule } from './analytics.module';

src/app/app.module.ts

@@ -1,20 +1,17 @@
 import {
-  Inject,
   InjectionToken,
   ModuleWithProviders,
   NgModule,
   NgZone,
   Optional,
-  PLATFORM_ID,
   VERSION as NG_VERSION,
 } from '@angular/core';
 import { FirebaseApp as IFirebaseApp, getApp, registerVersion } from 'firebase/app';
 
 import { FirebaseApp, FirebaseApps } from './app';
-import { VERSION, ɵmemoizeInstance } from '../core';
-import { ɵAngularFireSchedulers } from '../zones';
+import { VERSION, ɵmemoizeInstance, ɵAngularFireSchedulers } from '@angular/fire';
 
-export function ɵdefaultFirebaseAppFactory(_: FirebaseApp[]) {
+export function defaultFirebaseAppFactory(_: FirebaseApp[]) {
   return new FirebaseApp(getApp());
 }
 
@@ -28,7 +25,7 @@ export const PROVIDED_FIREBASE_APPS = new InjectionToken<Array<FirebaseApp>>('an
 // from the reserved URL.
 const DEFAULT_FIREBASE_APP_PROVIDER = {
   provide: FirebaseApp,
-  useFactory: ɵdefaultFirebaseAppFactory,
+  useFactory: defaultFirebaseAppFactory,
   deps: [
     [new Optional(), PROVIDED_FIREBASE_APPS ],
   ],
@@ -41,12 +38,11 @@ const FIREBASE_APPS_PROVIDER = {
   ],
 };
 
-// Hack: useFactory doesn't allow us to pass a lambda, so let's bind the arugments
-// Going this direction to cut down on DI token noise; also making it easier to support
-// multiple Firebase Apps
-export function ɵboundFirebaseAppFactory(zone: NgZone) {
-  const app = ɵmemoizeInstance<IFirebaseApp>(this, zone);
-  return new FirebaseApp(app);
+export function firebaseAppFactory(fn: () => IFirebaseApp) {
+  return (zone: NgZone) => {
+    const app = ɵmemoizeInstance<IFirebaseApp>(fn, zone);
+    return new FirebaseApp(app);
+  };
 }
 
 @NgModule({
@@ -55,7 +51,7 @@ export function ɵboundFirebaseAppFactory(zone: NgZone) {
     FIREBASE_APPS_PROVIDER,
   ]
 })
-export class AngularFireModule {
+export class FirebaseAppModule {
   constructor() {
     registerVersion('angularfire', VERSION.full, 'core');
     registerVersion('angular', NG_VERSION.full);
@@ -65,12 +61,12 @@ export class AngularFireModule {
 // Calling initializeApp({ ... }, 'name') multiple times will add more FirebaseApps into the FIREBASE_APPS
 // injection scope. This allows developers to more easily work with multiple Firebase Applications. Downside
 // is that DI for app name and options doesn't really make sense anymore.
-export function provideFirebaseApp(fn: () => IFirebaseApp): ModuleWithProviders<AngularFireModule> {
+export function provideFirebaseApp(fn: () => IFirebaseApp): ModuleWithProviders<FirebaseAppModule> {
   return {
-    ngModule: AngularFireModule,
+    ngModule: FirebaseAppModule,
     providers: [{
       provide: PROVIDED_FIREBASE_APPS,
-      useFactory: ɵboundFirebaseAppFactory.bind(fn),
+      useFactory: firebaseAppFactory(fn),
       multi: true,
       deps: [ NgZone, ɵAngularFireSchedulers ],
     }],

src/app/app.ts

@@ -1,4 +1,6 @@
 import { FirebaseApp as IFirebaseApp, getApps } from 'firebase/app';
+import { from, timer } from 'rxjs';
+import { concatMap, distinct } from 'rxjs/operators';
 
 // Need to turn the FirebaseApp interface exported by firebase/app into a class
 // as types don't work in Angular DI. We want developers to be able to inject FirebaseApp like so
@@ -29,3 +31,8 @@ export class FirebaseApps {
     return getApps();
   }
 }
+
+export const firebaseApp$ = timer(0, 300).pipe(
+  concatMap(() => from(getApps())),
+  distinct(),
+);

src/app/public_api.ts

@@ -1 +1,2 @@
-export { FirebaseApp, provideFirebaseApp, FirebaseApps } from '@angular/fire';
+export { FirebaseApp, FirebaseApps, firebaseApp$ } from './app';
+export { provideFirebaseApp, FirebaseAppModule } from './app.module';

src/auth/auth.module.ts

@@ -1,23 +1,22 @@
 import { NgModule, Optional, NgZone, InjectionToken, ModuleWithProviders } from '@angular/core';
-import { Auth as FirebaseAuth } from 'firebase/auth';
-import { ɵgetDefaultInstanceOf, ɵmemoizeInstance } from '../core';
+import { Auth as FirebaseAuth, initializeAuth } from 'firebase/auth';
+import { ɵgetDefaultInstanceOf, ɵmemoizeInstance, ɵAngularFireSchedulers } from '@angular/fire';
 import { Auth, AuthInstances, AUTH_PROVIDER_NAME } from './auth';
-import { ɵAngularFireSchedulers } from '../zones';
-import { PROVIDED_FIREBASE_APPS } from '../app/app.module';
+import { getApp } from 'firebase/app';
+import { FirebaseApps } from '@angular/fire/app';
 
 export const PROVIDED_AUTH_INSTANCES = new InjectionToken<Auth[]>('angularfire2.auth-instances');
 
-export function ɵdefaultAuthInstanceFactory() {
-  const defaultAuth = ɵgetDefaultInstanceOf<FirebaseAuth>(AUTH_PROVIDER_NAME);
+export function defaultAuthInstanceFactory() {
+  const defaultAuth = ɵgetDefaultInstanceOf<FirebaseAuth>(AUTH_PROVIDER_NAME) || initializeAuth(getApp());
   return new Auth(defaultAuth);
 }
 
-// Hack: useFactory doesn't allow us to pass a lambda, so let's bind the arugments
-// Going this direction to cut down on DI token noise; also making it easier to support
-// multiple Firebase Apps
-export function ɵboundAuthInstanceFactory(zone: NgZone) {
-  const auth = ɵmemoizeInstance<FirebaseAuth>(this, zone);
-  return new Auth(auth);
+export function authInstanceFactory(fn: () => FirebaseAuth) {
+  return (zone: NgZone) => {
+    const auth = ɵmemoizeInstance<FirebaseAuth>(fn, zone);
+    return new Auth(auth);
+  };
 }
 
 const AUTH_INSTANCES_PROVIDER = {
@@ -29,7 +28,7 @@ const AUTH_INSTANCES_PROVIDER = {
 
 const DEFAULT_AUTH_INSTANCE_PROVIDER = {
   provide: Auth,
-  useFactory: ɵdefaultAuthInstanceFactory,
+  useFactory: defaultAuthInstanceFactory,
   deps: [
     NgZone,
     [new Optional(), PROVIDED_AUTH_INSTANCES ],
@@ -50,12 +49,12 @@ export function provideAuth(fn: () => FirebaseAuth): ModuleWithProviders<AuthMod
     ngModule: AuthModule,
     providers: [{
       provide: PROVIDED_AUTH_INSTANCES,
-      useFactory: ɵboundAuthInstanceFactory.bind(fn),
+      useFactory: authInstanceFactory(fn),
       multi: true,
       deps: [
         NgZone,
         ɵAngularFireSchedulers,
-        [new Optional(), PROVIDED_FIREBASE_APPS ]
+        FirebaseApps,
       ]
     }]
   };

src/auth/auth.ts

@@ -1,5 +1,7 @@
 import { Auth as FirebaseAuth } from 'firebase/auth';
-import { ɵgetAllInstancesOf } from '../core';
+import { ɵgetAllInstancesOf } from '@angular/fire';
+import { from, timer } from 'rxjs';
+import { concatMap, distinct } from 'rxjs/operators';
 
 export const AUTH_PROVIDER_NAME = 'auth-exp';
 
@@ -21,3 +23,8 @@ export class AuthInstances {
     return ɵgetAllInstancesOf<FirebaseAuth>(AUTH_PROVIDER_NAME);
   }
 }
+
+export const authInstance$ = timer(0, 300).pipe(
+  concatMap(() => from(ɵgetAllInstancesOf<FirebaseAuth>(AUTH_PROVIDER_NAME))),
+  distinct(),
+);