fix(elementAt): Allow defaultValue of undefined.

spec-dtslint/operators/elementAt-spec.ts

@@ -13,10 +13,14 @@ it('should enforce types', () => {
   const o = of('foo').pipe(elementAt()); // $ExpectError
 });
 
-it('should enforce of index', () => {
+it('should enforce passing the index', () => {
   const o = of('foo').pipe(elementAt('foo')); // $ExpectError
 });
 
 it('should enforce of default', () => {
-  const o = of('foo').pipe(elementAt(5, 5)); // $ExpectError
+  const o = of('foo').pipe(elementAt(5, 5)); // $ExpectType Observable<string | number>
+});
+
+it('should allow undefined default', () => {
+  const o = of('foo').pipe(elementAt(100, undefined)); // $ExpectType Observable<string | undefined>
 });

spec/operators/elementAt-spec.ts

@@ -35,6 +35,17 @@ describe('elementAt', () => {
     });
   });
 
+  it('should allow undefined as a default value', () => {
+    testScheduler.run(({ hot, expectObservable, expectSubscriptions }) => {
+      const e1 = hot('  -----a--a---a-|   ');
+      const e1subs = '  ^-------------!   ';
+      const expected = '--------------(U|)';
+
+      expectObservable(e1.pipe(elementAt(100, undefined))).toBe(expected, { U: undefined });
+      expectSubscriptions(e1.subscriptions).toBe(e1subs);
+    });
+  });
+
   it('should return non-first element by zero-based index', () => {
     testScheduler.run(({ hot, expectObservable, expectSubscriptions }) => {
       const e1 = hot('  --a--b--c--d--e--f--|');

src/internal/operators/elementAt.ts

@@ -1,11 +1,14 @@
 import { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';
 import { Observable } from '../Observable';
-import { MonoTypeOperatorFunction } from '../types';
+import { MonoTypeOperatorFunction, OperatorFunction } from '../types';
 import { filter } from './filter';
 import { throwIfEmpty } from './throwIfEmpty';
 import { defaultIfEmpty } from './defaultIfEmpty';
 import { take } from './take';
 
+export function elementAt<T, D>(index: number): MonoTypeOperatorFunction<T>;
+export function elementAt<T, D>(index: number, defaultValue: D): OperatorFunction<T, T | D>;
+
 /**
  * Emits the single value at the specified `index` in a sequence of emissions
  * from the source Observable.
@@ -52,14 +55,15 @@ import { take } from './take';
  * @return {Observable} An Observable that emits a single item, if it is found.
  * Otherwise, will emit the default value if given. If not, then emits an error.
  */
-export function elementAt<T>(index: number, defaultValue?: T): MonoTypeOperatorFunction<T> {
-  if (index < 0) { throw new ArgumentOutOfRangeError(); }
+export function elementAt<T, D>(index: number, defaultValue?: D): OperatorFunction<T, T | D> {
+  if (index < 0) {
+    throw new ArgumentOutOfRangeError();
+  }
   const hasDefaultValue = arguments.length >= 2;
-  return (source: Observable<T>) => source.pipe(
-    filter((v, i) => i === index),
-    take(1),
-    hasDefaultValue
-      ? defaultIfEmpty(defaultValue)
-      : throwIfEmpty(() => new ArgumentOutOfRangeError()),
-  );
+  return (source: Observable<T>) =>
+    source.pipe(
+      filter((v, i) => i === index),
+      take(1),
+      hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new ArgumentOutOfRangeError())
+    );
 }