Cleaning things up, beyond docs ready for release

Author: jamesdaniels

src/analytics/analytics.service.ts

@@ -1,12 +1,12 @@
 import { Injectable, Optional, NgZone, OnDestroy, ComponentFactoryResolver, Inject, PLATFORM_ID, Injector, NgModuleFactory } from '@angular/core';
-import { Subscription, from, Observable, empty, of } from 'rxjs';
+import { Subscription, from, Observable, of } from 'rxjs';
 import { filter, withLatestFrom, switchMap, map, tap, pairwise, startWith, groupBy, mergeMap } from 'rxjs/operators';
 import { Router, NavigationEnd, ActivationEnd, ROUTES } from '@angular/router';
 import { runOutsideAngular } from '@angular/fire';
 import { AngularFireAnalytics, DEBUG_MODE } from './analytics';
 import { User } from 'firebase/app';
 import { Title } from '@angular/platform-browser';
-import { isPlatformBrowser } from '@angular/common';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 
 const FIREBASE_EVENT_ORIGIN_KEY = 'firebase_event_origin';
 const FIREBASE_PREVIOUS_SCREEN_CLASS_KEY = 'firebase_previous_class';
@@ -101,7 +101,7 @@ export class ScreenTrackingService implements OnDestroy {
                               const declarations = [].concat.apply([], (lazyModule[ANNOTATIONS] || []).map((f:any) => f.declarations));
                               const selectors = [].concat.apply([], declarations.map((c:any) => (c[ANNOTATIONS] || []).map((f:any) => f.selector)));
                               // should I just be grabbing the selector like this or should i match against the route component?
-                              //   const routerModule = lazyModule.ngInjectorDef.imports.find(i => !!i.ngModule);
+                              //   const routerModule = lazyModule.ngInjectorDef.imports.find(i => i.ngModule && ....);
                               //   const route = routerModule.providers[0].find(p => p.provide == ROUTES).useValue[0];
                               return {...params, [SCREEN_CLASS_KEY]: selectors[0] || DEFAULT_SCREEN_CLASS};
                             }
@@ -157,15 +157,21 @@ export class UserTrackingService implements OnDestroy {
     // TODO a user properties injector
     constructor(
         analytics: AngularFireAnalytics,
-        zone: NgZone
+        zone: NgZone,
+        @Inject(PLATFORM_ID) platformId:Object
     ) {
-        this.disposable = from(analytics.app).pipe(
-            // TODO can I hook into auth being loaded...
-            map(app => app.auth()),
-            switchMap(auth => auth ? new Observable<User>(auth.onAuthStateChanged.bind(auth)) : empty()),
-            switchMap(user => analytics.setUserId(user ? user.uid : null!)),
-            runOutsideAngular(zone)
-        ).subscribe();
+        if (!isPlatformServer(platformId)) {
+            zone.runOutsideAngular(() => {
+                // @ts-ignore zap the import in the UMD
+                this.disposable = from(import('firebase/auth')).pipe(
+                    switchMap(() => analytics.app),
+                    map(app => app.auth()),
+                    switchMap(auth => new Observable<User|null>(auth.onAuthStateChanged.bind(auth))),
+                    switchMap(user => analytics.setUserId(user ? user.uid : null!)),
+                    runOutsideAngular(zone)
+                ).subscribe();
+            });
+        }
     }
 
     ngOnDestroy() {

src/analytics/analytics.ts

@@ -89,7 +89,7 @@ export class AngularFireAnalytics {
         if (analyticsCollectionEnabled === false) { analytics.setAnalyticsCollectionEnabled(false) }
       }),
       runOutsideAngular(zone),
-      shareReplay(1)
+      shareReplay({ bufferSize: 1, refCount: false }),
     );
 
     return ɵlazySDKProxy(this, analytics, zone);

src/core/angularfire2.ts

@@ -80,10 +80,24 @@ export const runInZone = (zone: NgZone) => <T>(obs$: Observable<T>): Observable<
     { [K in PromiseReturningFunctionPropertyNames<T>   ]: (...args: Parameters<T[K]>) => ReturnType<T[K]> };
 */
 
-export const ɵlazySDKProxy = (klass: any, observable: Observable<any>, zone: NgZone) => new Proxy(klass, {
-  get: (_, name) => zone.runOutsideAngular(() =>
-    klass[name] || new Proxy(() => 
-      observable.toPromise().then(mod => {
+// DEBUG quick debugger function for inline logging that typescript doesn't complain about
+//       wrote it for debugging the ɵlazySDKProxy, commenting out for now; should consider exposing a
+//       verbose mode for AngularFire in a future release that uses something like this in multiple places
+//       usage: () => log('something') || returnValue
+// const log = (...args: any[]): false => { console.log(...args); return false }
+
+// The problem here are things like ngOnDestroy are missing, then triggering the service
+// rather than dig too far; I'm capturing these as I go.
+const noopFunctions = ['ngOnDestroy'];
+
+// INVESTIGATE should we make the Proxy revokable and do some cleanup?
+//             right now it's fairly simple but I'm sure this will grow in complexity
+export const ɵlazySDKProxy = (klass: any, observable: Observable<any>, zone: NgZone) => {
+  return new Proxy(klass, {
+    get: (_, name:string) => zone.runOutsideAngular(() => {
+      if (klass[name]) { return klass[name] }
+      if (noopFunctions.includes(name)) { return () => {} }
+      let promise = observable.toPromise().then(mod => {
         const ret = mod && mod[name];
         // TODO move to proper type guards
         if (typeof ret == 'function') {
@@ -93,15 +107,14 @@ export const ɵlazySDKProxy = (klass: any, observable: Observable<any>, zone: Ng
         } else {
           return zone.run(() => ret);
         }
-      }), {
-        get: (self, name) => {
-          const ret = self();
-          // TODO proxy so we can have apply?
-          return ret && ret[name] || (() => {});
-        },
-        // TODO handle callbacks as transparently as I can 
-        apply: (self, _, args) => self().then(it => it && it(...args))
-      }
-    )
-  )
-});
+      });
+      // recurse the proxy
+      return new Proxy(() => undefined, {
+          get: (_, name) => promise[name],
+          // TODO handle callbacks as transparently as I can 
+          apply: (self, _, args) => promise.then(it => it && it(...args))
+        }
+      )
+    })
+  })
+};

src/remote-config/remote-config.ts

@@ -10,7 +10,6 @@ export const REMOTE_CONFIG_SETTINGS = new InjectionToken<remoteConfig.Settings>(
 export const DEFAULT_CONFIG = new InjectionToken<ConfigTemplate>('angularfire2.remoteConfig.defaultConfig');
 
 import { FirebaseRemoteConfig, _firebaseAppFactory, runOutsideAngular } from '@angular/fire';
-import { isPlatformServer } from '@angular/common';
 
 // SEMVER: once we move to Typescript 3.6 use `PromiseProxy<remoteConfig.RemoteConfig>` rather than hardcoding
 type RemoteConfigProxy = {
@@ -127,8 +126,7 @@ export class AngularFireRemoteConfig {
     this.booleans = proxyAll(this.parameters, 'booleans');
     this.numbers  = proxyAll(this.parameters, 'numbers');
 
-    // TODO fix the proxy for server
-    return isPlatformServer(platformId) ? this : ɵlazySDKProxy(this, remoteConfig$, zone);
+    return ɵlazySDKProxy(this, loadedRemoteConfig$, zone);
   }
 
 }