chore(lint): Misc fixes

NothingEverHappens · NothingEverHappens · commit 7921520a4ece · 2020-04-28T19:51:08.000-04:00
diff --git a/src/auth/auth.spec.ts b/src/auth/auth.spec.ts
@@ -76,35 +76,43 @@ describe('AngularFireAuth', () => {
     let count = 0;
 
     // Check that the first value is null and second is the auth user
-    const subs = afAuth.authState.subscribe(user => {
-      if (count === 0) {
-        expect(user).toBe(null);
-        count = count + 1;
-        mockAuthState.next(firebaseUser);
-      } else {
-        expect(user).toEqual(firebaseUser);
-        subs.unsubscribe();
-        done();
-      }
-    }, done, done.fail);
+    const subs = afAuth.authState.subscribe({
+      next: (user => {
+        if (count === 0) {
+          expect(user).toBe(null);
+          count = count + 1;
+          mockAuthState.next(firebaseUser);
+        } else {
+          expect(user).toEqual(firebaseUser);
+          subs.unsubscribe();
+          done();
+        }
+      }),
+      error: done,
+      complete: done.fail
+    });
     mockAuthState.next(null);
   });
 
   it('should emit auth updates through idToken', (done: any) => {
     let count = 0;
 
     // Check that the first value is null and second is the auth user
-    const subs = afAuth.idToken.subscribe(user => {
-      if (count === 0) {
-        expect(user).toBe(null);
-        count = count + 1;
-        mockAuthState.next(firebaseUser);
-      } else {
-        expect(user as any).toEqual(firebaseUser);
-        subs.unsubscribe();
-        done();
-      }
-    }, done, done.fail);
+    const subs = afAuth.idToken.subscribe({
+      next: user => {
+        if (count === 0) {
+          expect(user).toBe(null);
+          count = count + 1;
+          mockAuthState.next(firebaseUser);
+        } else {
+          expect(user as any).toEqual(firebaseUser);
+          subs.unsubscribe();
+          done();
+        }
+      },
+      error: done,
+      complete: done.fail
+    });
     mockAuthState.next(null);
   });
 
diff --git a/src/auth/auth.ts b/src/auth/auth.ts
@@ -46,6 +46,7 @@ export class AngularFireAuth {
   constructor(
     @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,
     @Optional() @Inject(FIREBASE_APP_NAME) nameOrConfig: string|FirebaseAppConfig|null|undefined,
+    // tslint:disable-next-line:ban-types
     @Inject(PLATFORM_ID) platformId: Object,
     zone: NgZone
   ) {
diff --git a/src/core/firebase.app.module.ts b/src/core/firebase.app.module.ts
@@ -3,67 +3,74 @@ import * as firebase from 'firebase/app';
 import { analytics, app, auth, database, firestore, functions, messaging, performance, remoteConfig, storage } from 'firebase/app';
 
 // INVESTIGATE Public types don't expose FirebaseOptions or FirebaseAppConfig, is this the case anylonger?
-export interface FirebaseOptions {[key: string]: any; }
-export interface FirebaseAppConfig {[key: string]: any; }
+export interface FirebaseOptions {
+  [key: string]: any;
+}
+
+export interface FirebaseAppConfig {
+  [key: string]: any;
+}
 
 export const FIREBASE_OPTIONS = new InjectionToken<FirebaseOptions>('angularfire2.app.options');
-export const FIREBASE_APP_NAME = new InjectionToken<string|FirebaseAppConfig|undefined>('angularfire2.app.nameOrConfig');
+export const FIREBASE_APP_NAME = new InjectionToken<string | FirebaseAppConfig | undefined>('angularfire2.app.nameOrConfig');
 
 // Have to implement as we need to return a class from the provider, we should consider exporting
 // this in the firebase/app types as this is our highest risk of breaks
 export class FirebaseApp implements Partial<app.App> {
-    name: string;
-    options: {};
-    analytics: () => analytics.Analytics;
-    auth: () => auth.Auth;
-    database: (databaseURL?: string) => database.Database;
-    messaging: () => messaging.Messaging;
-    performance: () => performance.Performance;
-    storage: (storageBucket?: string) => storage.Storage;
-    delete: () => Promise<void>;
-    firestore: () => firestore.Firestore;
-    functions: (region?: string) => functions.Functions;
-    remoteConfig: () => remoteConfig.RemoteConfig;
+  name: string;
+  options: {};
+  analytics: () => analytics.Analytics;
+  auth: () => auth.Auth;
+  database: (databaseURL?: string) => database.Database;
+  messaging: () => messaging.Messaging;
+  performance: () => performance.Performance;
+  storage: (storageBucket?: string) => storage.Storage;
+  delete: () => Promise<void>;
+  firestore: () => firestore.Firestore;
+  functions: (region?: string) => functions.Functions;
+  remoteConfig: () => remoteConfig.RemoteConfig;
 }
 
 export const VERSION = new Version('ANGULARFIRE2_VERSION');
 
-export function ɵfirebaseAppFactory(options: FirebaseOptions, zone: NgZone, nameOrConfig?: string|FirebaseAppConfig|null) {
-    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] as any;
-    // 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
-    return (existingApp || zone.runOutsideAngular(() => firebase.initializeApp(options, config as any))) as FirebaseApp;
+export function ɵfirebaseAppFactory(options: FirebaseOptions, zone: NgZone, nameOrConfig?: string | FirebaseAppConfig | null) {
+  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] as any;
+  // 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
+  return (existingApp || zone.runOutsideAngular(() => firebase.initializeApp(options, config as any))) as FirebaseApp;
 }
 
 const FirebaseAppProvider = {
-    provide: FirebaseApp,
-    useFactory: ɵfirebaseAppFactory,
-    deps: [
-        FIREBASE_OPTIONS,
-        NgZone,
-        [new Optional(), FIREBASE_APP_NAME]
-    ]
+  provide: FirebaseApp,
+  useFactory: ɵfirebaseAppFactory,
+  deps: [
+    FIREBASE_OPTIONS,
+    NgZone,
+    [new Optional(), FIREBASE_APP_NAME]
+  ]
 };
 
 @NgModule({
-    providers: [ FirebaseAppProvider ],
+  providers: [FirebaseAppProvider]
 })
 export class AngularFireModule {
-    static initializeApp(options: FirebaseOptions, nameOrConfig?: string | FirebaseAppConfig) {
-        return {
-            ngModule: AngularFireModule,
-            providers: [
-                { provide: FIREBASE_OPTIONS, useValue: options },
-                { provide: FIREBASE_APP_NAME, useValue: nameOrConfig }
-            ]
-        };
-    }
-    constructor(@Inject(PLATFORM_ID) platformId: Object ) {
-        firebase.registerVersion('angularfire', VERSION.full, platformId.toString());
-        firebase.registerVersion('angular', NG_VERSION.full);
-    }
+  static initializeApp(options: FirebaseOptions, nameOrConfig?: string | FirebaseAppConfig) {
+    return {
+      ngModule: AngularFireModule,
+      providers: [
+        { provide: FIREBASE_OPTIONS, useValue: options },
+        { provide: FIREBASE_APP_NAME, useValue: nameOrConfig }
+      ]
+    };
+  }
+
+  // tslint:disable-next-line:ban-types
+  constructor(@Inject(PLATFORM_ID) platformId: Object) {
+    firebase.registerVersion('angularfire', VERSION.full, platformId.toString());
+    firebase.registerVersion('angular', NG_VERSION.full);
+  }
 }
diff --git a/src/firestore/observable/fromRef.ts b/src/firestore/observable/fromRef.ts
@@ -13,7 +13,7 @@ function _fromRef<T, R>(ref: Reference<T>, scheduler: SchedulerLike = asyncSched
       unsubscribe = ref.onSnapshot(subscriber);
     }
 
-    return function() {
+    return () => {
       if (unsubscribe != null) {
         unsubscribe();
       }
diff --git a/src/functions/functions.ts b/src/functions/functions.ts
@@ -1,28 +1,38 @@
 import { Inject, Injectable, InjectionToken, NgZone, Optional } from '@angular/core';
 import { from, Observable, of } from 'rxjs';
 import { map, observeOn, shareReplay, switchMap, tap } from 'rxjs/operators';
-import { FIREBASE_APP_NAME, FIREBASE_OPTIONS, FirebaseAppConfig, FirebaseOptions, ɵAngularFireSchedulers, ɵfirebaseAppFactory, ɵlazySDKProxy, ɵPromiseProxy } from '@angular/fire';
+import {
+  FIREBASE_APP_NAME,
+  FIREBASE_OPTIONS,
+  FirebaseAppConfig,
+  FirebaseOptions,
+  ɵAngularFireSchedulers,
+  ɵfirebaseAppFactory,
+  ɵlazySDKProxy,
+  ɵPromiseProxy
+} from '@angular/fire';
 import { functions } from 'firebase/app';
 
 export const ORIGIN = new InjectionToken<string>('angularfire2.functions.origin');
 export const REGION = new InjectionToken<string>('angularfire2.functions.region');
 
 // override httpsCallable for compatibility with 5.x
-export interface AngularFireFunctions extends Omit<ɵPromiseProxy<functions.Functions>, 'httpsCallable'> { }
+export interface AngularFireFunctions extends Omit<ɵPromiseProxy<functions.Functions>, 'httpsCallable'> {
+}
 
 @Injectable({
   providedIn: 'any'
 })
 export class AngularFireFunctions {
 
-  public readonly httpsCallable: <T= any, R= any>(name: string) => (data: T) => Observable<R>;
+  public readonly httpsCallable: <T = any, R = any>(name: string) => (data: T) => Observable<R>;
 
   constructor(
     @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,
-    @Optional() @Inject(FIREBASE_APP_NAME) nameOrConfig: string|FirebaseAppConfig|null|undefined,
+    @Optional() @Inject(FIREBASE_APP_NAME) nameOrConfig: string | FirebaseAppConfig | null | undefined,
     zone: NgZone,
-    @Optional() @Inject(REGION) region: string|null,
-    @Optional() @Inject(ORIGIN) origin: string|null
+    @Optional() @Inject(REGION) region: string | null,
+    @Optional() @Inject(ORIGIN) origin: string | null
   ) {
     const schedulers = new ɵAngularFireSchedulers(zone);
 
@@ -32,12 +42,14 @@ export class AngularFireFunctions {
       map(() => ɵfirebaseAppFactory(options, zone, nameOrConfig)),
       map(app => app.functions(region || undefined)),
       tap(functions => {
-        if (origin) { functions.useFunctionsEmulator(origin); }
+        if (origin) {
+          functions.useFunctionsEmulator(origin);
+        }
       }),
-      shareReplay({ bufferSize: 1, refCount: false }),
+      shareReplay({ bufferSize: 1, refCount: false })
     );
 
-    this.httpsCallable = <T= any, R= any>(name: string) =>
+    this.httpsCallable = <T = any, R = any>(name: string) =>
       (data: T) => from(functions).pipe(
         observeOn(schedulers.outsideAngular),
         switchMap(functions => functions.httpsCallable(name)(data)),
diff --git a/src/remote-config/remote-config.ts b/src/remote-config/remote-config.ts
@@ -15,6 +15,9 @@ export const DEFAULTS = new InjectionToken<ConfigTemplate>('angularfire2.remoteC
 export interface AngularFireRemoteConfig extends ɵPromiseProxy<remoteConfig.RemoteConfig> {
 }
 
+const AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };
+const STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };
+
 // TODO look into the types here, I don't like the anys
 const proxyAll = (observable: Observable<Parameter[]>, as: 'numbers' | 'booleans' | 'strings') => new Proxy(
   observable.pipe(mapToObject(as as any)), {
@@ -66,6 +69,30 @@ export const filterRemote = () => filterTest(p => p.getSource() === 'remote');
 // filterFresh allows the developer to effectively set up a maximum cache time
 export const filterFresh = (howRecentInMillis: number) => filterTest(p => p.fetchTimeMillis + howRecentInMillis >= new Date().getTime());
 
+
+// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.
+// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis
+// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,
+// which we can simplify to === rather than deep comparison
+const scanToParametersArray = (
+  remoteConfig: Observable<remoteConfig.RemoteConfig | undefined>
+): OperatorFunction<{ [key: string]: remoteConfig.Value }, Parameter[]> => pipe(
+  withLatestFrom(remoteConfig),
+  scan((existing, [all, rc]) => {
+    // SEMVER use "new Set" to unique once we're only targeting es6
+    // at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness
+    // implementation.
+    // const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];
+    const allKeys = [...existing.map(p => p.key), ...Object.keys(all)].filter((v, i, a) => a.indexOf(v) === i);
+    return allKeys.map(key => {
+      const updatedValue = all[key];
+      return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())
+        : existing.find(p => p.key === key);
+    });
+  }, [] as Array<Parameter>)
+);
+
+
 @Injectable({
   providedIn: 'any'
 })
@@ -162,28 +189,6 @@ export class AngularFireRemoteConfig {
 
 }
 
-// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.
-// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis
-// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,
-// which we can simplify to === rather than deep comparison
-const scanToParametersArray = (
-  remoteConfig: Observable<remoteConfig.RemoteConfig | undefined>
-): OperatorFunction<{ [key: string]: remoteConfig.Value }, Parameter[]> => pipe(
-  withLatestFrom(remoteConfig),
-  scan((existing, [all, rc]) => {
-    // SEMVER use "new Set" to unique once we're only targeting es6
-    // at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness
-    // implementation.
-    // const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];
-    const allKeys = [...existing.map(p => p.key), ...Object.keys(all)].filter((v, i, a) => a.indexOf(v) === i);
-    return allKeys.map(key => {
-      const updatedValue = all[key];
-      return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())
-        : existing.find(p => p.key === key);
-    });
-  }, [] as Array<Parameter>)
-);
-
 
 export const budget = <T>(interval: number): MonoTypeOperatorFunction<T> => (source: Observable<T>) => new Observable<T>(observer => {
   let timedOut = false;
@@ -226,8 +231,6 @@ const typedMethod = (it: any) => {
   }
 };
 
-const AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };
-const STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };
 
 export function scanToObject(): OperatorFunction<Parameter, { [key: string]: string | undefined }>;
 export function scanToObject(to: 'numbers'): OperatorFunction<Parameter, { [key: string]: number | undefined }>;
diff --git a/src/schematics/ng-add-common.ts b/src/schematics/ng-add-common.ts
@@ -76,6 +76,7 @@ export function generateFirebaseRc(
 
 export function safeReadJSON(path: string, tree: Tree) {
   try {
+    // tslint:disable-next-line:no-non-null-assertion
     return JSON.parse(tree.read(path)!.toString());
   } catch (e) {
     throw new SchematicsException(`Error when parsing ${path}: ${e.message}`);

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ function _fromRef<T, R>(ref: Reference<T>, scheduler: SchedulerLike = asyncSched`
`13`	`13`	`unsubscribe = ref.onSnapshot(subscriber);`
`14`	`14`	`}`
`15`	`15`
`16`		`- return function() {`
	`16`	`+ return () => {`
`17`	`17`	`if (unsubscribe != null) {`
`18`	`18`	`unsubscribe();`
`19`	`19`	`}`