fix(startWith): allow empty type signature and passing a different type

* fix(startWith): add empty signature * test(dtslint): add startWith tests * feat(startWith): allow different types * fix(compat): add typings to startWith
ReactiveX · Aug 27, 2018 · b7866a0 · b7866a0
1 parent 9ea0ec9
commit b7866a0
Show file tree

Hide file tree

Showing 4 changed files with 51 additions and 19 deletions.
diff --git a/compat/operator/startWith.ts b/compat/operator/startWith.ts
@@ -2,13 +2,14 @@ import { Observable, SchedulerLike } from 'rxjs';
 import { startWith as higherOrder } from 'rxjs/operators';
 
 /* tslint:disable:max-line-length */
-export function startWith<T>(this: Observable<T>, v1: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, v1: T, v2: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: SchedulerLike): Observable<T>;
-export function startWith<T>(this: Observable<T>, ...array: Array<T | SchedulerLike>): Observable<T>;
+export function startWith<T>(this: Observable<T>, scheduler?: SchedulerLike): Observable<T>;
+export function startWith<T, D = T>(this: Observable<T>, v1: D, scheduler?: SchedulerLike): Observable<T | D>;
+export function startWith<T, D = T, E = T>(this: Observable<T>, v1: D, v2: E, scheduler?: SchedulerLike): Observable<T | D | E>;
+export function startWith<T, D = T, E = T, F = T>(this: Observable<T>, v1: D, v2: E, v3: F, scheduler?: SchedulerLike): Observable<T | D | E | F>;
+export function startWith<T, D = T, E = T, F = T, G = T>(this: Observable<T>, v1: D, v2:  E, v3: F, v4: G, scheduler?: SchedulerLike): Observable<T | D | E | F | G>;
+export function startWith<T, D = T, E = T, F = T, G = T, H = T>(this: Observable<T>, v1: D, v2: E, v3: F, v4: G, v5: H, scheduler?: SchedulerLike): Observable<T | D | E | F | G | H>;
+export function startWith<T, D = T, E = T, F = T, G = T, H = T, I = T>(this: Observable<T>, v1: D, v2: E, v3: F, v4: G, v5: H, v6: I, scheduler?: SchedulerLike): Observable<T | D | E | F | G | H | I>;
+export function startWith<T, D = T>(this: Observable<T>, ...array: Array<D | SchedulerLike>): Observable<T | D>;
 /* tslint:enable:max-line-length */
 
 /**
@@ -25,6 +26,6 @@ export function startWith<T>(this: Observable<T>, ...array: Array<T | SchedulerL
  * @method startWith
  * @owner Observable
  */
-export function startWith<T>(this: Observable<T>, ...array: Array<T | SchedulerLike>): Observable<T> {
-  return higherOrder(...array)(this);
+export function startWith<T, D>(this: Observable<T>, ...array: Array<D | SchedulerLike>): Observable<T |D> {
+  return higherOrder<T, D>(...array)(this);
 }
diff --git a/spec-dtslint/operators/startWith-spec.ts b/spec-dtslint/operators/startWith-spec.ts
@@ -0,0 +1,30 @@
+import { of, asyncScheduler  } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+
+it('should infer correctly with one value', () => {
+  const o = of(1, 2, 3).pipe(startWith(4)); // $ExpectType Observable<number>
+});
+
+it('should infer correctly with multiple values', () => {
+  const o = of(1, 2, 3).pipe(startWith(4, 5, 6)); // $ExpectType Observable<number>
+});
+
+it('should infer correctly with no value', () => {
+  const o = of(1, 2, 3).pipe(startWith()); // $ExpectType Observable<number>
+});
+
+it('should infer correctly with a value and a scheduler', () => {
+  const o = of(1, 2, 3).pipe(startWith(5, asyncScheduler)); // $ExpectType Observable<number>
+});
+
+it('should infer correctly with a different type', () => {
+  const o = of(1, 2, 3).pipe(startWith('foo')); // $ExpectType Observable<string | number>
+});
+
+it('should infer correctly with multiple different types', () => {
+  const o = of(1, 2, 3).pipe(startWith('foo', 4, true)); // $ExpectType Observable<string | number | boolean>
+});
+
+it('should infer correctly with only a scheduler', () => {
+  const o = of(1, 2, 3).pipe(startWith(asyncScheduler)); // $ExpectType Observable<number>
+});
diff --git a/spec/operators/startWith-spec.ts b/spec/operators/startWith-spec.ts
@@ -136,7 +136,7 @@ describe('startWith operator', () => {
     const e1subs =   '^  !';
     const expected = '-a-|';
 
-    expectObservable(e1.pipe(startWith<any>(rxTestScheduler))).toBe(expected);
+    expectObservable(e1.pipe(startWith(rxTestScheduler))).toBe(expected);
     expectSubscriptions(e1.subscriptions).toBe(e1subs);
   });
 

diff --git a/src/internal/operators/startWith.ts b/src/internal/operators/startWith.ts
@@ -4,16 +4,17 @@ import { scalar } from '../observable/scalar';
 import { empty } from '../observable/empty';
 import { concat as concatStatic } from '../observable/concat';
 import { isScheduler } from '../util/isScheduler';
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+import { MonoTypeOperatorFunction, OperatorFunction, SchedulerLike } from '../types';
 
 /* tslint:disable:max-line-length */
-export function startWith<T>(v1: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(v1: T, v2: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(v1: T, v2: T, v3: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(v1: T, v2: T, v3: T, v4: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-export function startWith<T>(...array: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T>;
+export function startWith<T>(scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+export function startWith<T, D = T>(v1: D, scheduler?: SchedulerLike): OperatorFunction<T, T | D>;
+export function startWith<T, D = T, E = T>(v1: D, v2: E, scheduler?: SchedulerLike): OperatorFunction<T, T | D | E>;
+export function startWith<T, D = T, E = T, F = T>(v1: D, v2: E, v3: F, scheduler?: SchedulerLike): OperatorFunction<T, T | D | E | F>;
+export function startWith<T, D = T, E = T, F = T, G = T>(v1: D, v2:  E, v3: F, v4: G, scheduler?: SchedulerLike): OperatorFunction<T, T | D | E | F | G>;
+export function startWith<T, D = T, E = T, F = T, G = T, H = T>(v1: D, v2: E, v3: F, v4: G, v5: H, scheduler?: SchedulerLike): OperatorFunction<T, T | D | E | F | G | H>;
+export function startWith<T, D = T, E = T, F = T, G = T, H = T, I = T>(v1: D, v2: E, v3: F, v4: G, v5: H, v6: I, scheduler?: SchedulerLike): OperatorFunction<T, T | D | E | F | G | H | I>;
+export function startWith<T, D = T>(...array: Array<D | SchedulerLike>): OperatorFunction<T, T | D>;
 /* tslint:enable:max-line-length */
 
 /**
@@ -48,7 +49,7 @@ export function startWith<T>(...array: Array<T | SchedulerLike>): MonoTypeOperat
  * @method startWith
  * @owner Observable
  */
-export function startWith<T>(...array: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T> {
+export function startWith<T, D>(...array: Array<T | SchedulerLike>): OperatorFunction<T, T | D> {
   return (source: Observable<T>) => {
     let scheduler = <SchedulerLike>array[array.length - 1];
     if (isScheduler(scheduler)) {