chore(typings): fix first/last typings

Author: cartant

compat/operator/first.ts

@@ -1,8 +1,12 @@
 import { Observable } from 'rxjs';
 import { first as higherOrder } from 'rxjs/operators';
 
-export function first<T>(this: Observable<T>, predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-                         defaultValue?: T): Observable<T>;
+/* tslint:disable:max-line-length */
+export function first<T>(this: Observable<T>, predicate?: null, defaultValue?: T): Observable<T>;
+export function first<T, S extends T>(this: Observable<T>, predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue?: T): Observable<S>;
+export function first<T>(this: Observable<T>, predicate: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T): Observable<T>;
+/* tslint:enable:max-line-length */
+
 /**
  * Emits only the first value (or the first value that meets some condition)
  * emitted by the source Observable.
@@ -47,5 +51,5 @@ export function first<T>(this: Observable<T>, predicate?: (value: T, index: numb
  * @owner Observable
  */
 export function first<T>(this: Observable<T>, ...args: any[]): Observable<T> {
-    return higherOrder<T>(...args)(this);
-  }
+  return higherOrder<T>(...args)(this);
+}

compat/operator/last.ts

@@ -1,8 +1,11 @@
 import { Observable } from 'rxjs';
 import { last as higherOrder } from 'rxjs/operators';
 
-export function last<T>(this: Observable<T>, predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-                        defaultValue?: T): Observable<T>;
+/* tslint:disable:max-line-length */
+export function last<T>(this: Observable<T>, predicate?: null, defaultValue?: T): Observable<T>;
+export function last<T, S extends T>(this: Observable<T>, predicate: (value: T, index: number, source: Observable<T>) => value is S, defaultValue?: T): Observable<S>;
+export function last<T>(this: Observable<T>, predicate: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T): Observable<T>;
+/* tslint:enable:max-line-length */
 /**
  * Returns an Observable that emits only the last item emitted by the source Observable.
  * It optionally takes a predicate function as a parameter, in which case, rather than emitting

spec/operators/first-spec.ts

@@ -217,6 +217,12 @@ describe('Observable.prototype.first', () => {
       // missing predicate preserves the type
       xs.pipe(first()).subscribe(x => x); // x is still string | number
 
+      // null predicate preserves the type
+      xs.pipe(first(null)).subscribe(x => x); // x is still string | number
+
+      // undefined predicate preserves the type
+      xs.pipe(first(undefined)).subscribe(x => x); // x is still string | number
+
       // After the type guard `first` predicates, the type is narrowed to string
       xs.pipe(first(isString))
         .subscribe(s => s.length); // s is string

spec/operators/last-spec.ts

@@ -160,6 +160,12 @@ describe('Observable.prototype.last', () => {
       // missing predicate preserves the type
       xs.pipe(last()).subscribe(x => x); // x is still string | number
 
+      // null predicate preserves the type
+      xs.pipe(last(null)).subscribe(x => x); // x is still string | number
+
+      // undefined predicate preserves the type
+      xs.pipe(last(undefined)).subscribe(x => x); // x is still string | number
+
       // After the type guard `last` predicates, the type is narrowed to string
       xs.pipe(last(isString))
         .subscribe(s => s.length); // s is string

src/internal/operators/first.ts

@@ -10,17 +10,16 @@ import { throwIfEmpty } from './throwIfEmpty';
 import { identity } from '../util/identity';
 
 /* tslint:disable:max-line-length */
-export function first<T>(): MonoTypeOperatorFunction<T>;
 export function first<T>(
-  predicate: null | undefined,
-  defaultValue: T
+  predicate?: null,
+  defaultValue?: T
 ): MonoTypeOperatorFunction<T>;
 export function first<T, S extends T>(
-  predicate?: (value: T, index: number, source: Observable<T>) => value is S,
+  predicate: (value: T, index: number, source: Observable<T>) => value is S,
   defaultValue?: T
 ): OperatorFunction<T, S>;
 export function first<T>(
-  predicate?: (value: T, index: number, source: Observable<T>) => boolean,
+  predicate: (value: T, index: number, source: Observable<T>) => boolean,
   defaultValue?: T
 ): MonoTypeOperatorFunction<T>;
 /* tslint:enable:max-line-length */

src/internal/operators/last.ts

@@ -10,17 +10,16 @@ import { defaultIfEmpty } from './defaultIfEmpty';
 import { identity } from '../util/identity';
 
 /* tslint:disable:max-line-length */
-export function last<T>(): MonoTypeOperatorFunction<T>;
 export function last<T>(
-  predicate: null | undefined,
-  defaultValue: T
+  predicate?: null,
+  defaultValue?: T
 ): MonoTypeOperatorFunction<T>;
 export function last<T, S extends T>(
-  predicate?: (value: T, index: number, source: Observable<T>) => value is S,
+  predicate: (value: T, index: number, source: Observable<T>) => value is S,
   defaultValue?: T
 ): OperatorFunction<T, S>;
 export function last<T>(
-  predicate?: (value: T, index: number, source: Observable<T>) => boolean,
+  predicate: (value: T, index: number, source: Observable<T>) => boolean,
   defaultValue?: T
 ): MonoTypeOperatorFunction<T>;
 /* tslint:enable:max-line-length */