chore(typings): fixed compiler errors due to change of interfaces

Author: david-driscoll

package.json

@@ -72,7 +72,7 @@
     "commit": "git-cz",
     "compile_dist_amd": "tsc typings/main/ambient/es6-shim/index.d.ts ./spec/es5.d.ts ./dist/amd/src/Rx.ts ./dist/amd/src/Rx.KitchenSink.ts ./dist/amd/src/Rx.DOM.ts ./dist/amd/src/add/observable/of.ts -m amd      --sourceMap --outDir ./dist/amd --target ES5    --diagnostics --pretty --noImplicitAny --suppressImplicitAnyIndexErrors",
     "compile_dist_cjs": "tsc typings/main/ambient/es6-shim/index.d.ts ./spec/es5.d.ts ./dist/cjs/src/Rx.ts ./dist/cjs/src/Rx.KitchenSink.ts ./dist/cjs/src/Rx.DOM.ts ./dist/cjs/src/add/observable/of.ts -m commonjs --sourceMap --outDir ./dist/cjs --target ES5 -d --diagnostics --pretty --noImplicitAny --suppressImplicitAnyIndexErrors",
-    "compile_dist_es6": "tsc                                          ./spec/es5.d.ts ./dist/es6/src/Rx.ts ./dist/es6/src/Rx.KitchenSink.ts ./dist/es6/src/Rx.DOM.ts ./dist/es6/src/add/observable/of.ts -m es2015   --sourceMap --outDir ./dist/es6 --target ES6 -d --diagnostics --pretty --noImplicitAny --suppressImplicitAnyIndexErrors",
+    "compile_dist_es6": "tsc                                                          ./dist/es6/src/Rx.ts ./dist/es6/src/Rx.KitchenSink.ts ./dist/es6/src/Rx.DOM.ts ./dist/es6/src/add/observable/of.ts -m es2015   --sourceMap --outDir ./dist/es6 --target ES6 -d --diagnostics --pretty --noImplicitAny --suppressImplicitAnyIndexErrors",
     "cover": "npm-run-all cover_test cover_remapping",
     "cover_test": "rm -rf dist/cjs && tsc typings/main/ambient/es6-shim/index.d.ts src/Rx.ts src/Rx.KitchenSink.ts src/Rx.DOM.ts src/add/observable/of.ts -m commonjs --outDir dist/cjs --sourceMap --target ES5 -d && istanbul cover -x \"spec-js/**/*\" ./node_modules/mocha/bin/_mocha -- --opts spec/support/default.opts spec-js",
     "cover_remapping": "remap-istanbul -i coverage/coverage.json -o coverage/coverage-remapped.json && remap-istanbul -i coverage/coverage.json -o coverage/coverage-remapped.lcov -t lcovonly && remap-istanbul -i coverage/coverage.json -o coverage/coverage-remapped -t html",

spec/observables/from-spec.ts

@@ -1,8 +1,9 @@
 import {expect} from 'chai';
 import * as Rx from '../../dist/cjs/Rx.KitchenSink';
 import {$$iterator} from '../../dist/cjs/symbol/iterator';
+import {Observablesque} from '../../dist/cjs/Observable';
 
-declare const {expectObservable, Symbol};
+declare const {expectObservable, Symbol, type};
 declare const rxTestScheduler: Rx.TestScheduler;
 const Observable = Rx.Observable;
 
@@ -26,7 +27,7 @@ describe('Observable.from', () => {
   it('should handle an ArrayLike', function (done: MochaDone) {
     this.timeout(300);
 
-    const arrayLike = {
+    const arrayLike: ArrayLike<number> = {
       length: 3,
       0: 1,
       1: 2,
@@ -64,7 +65,7 @@ describe('Observable.from', () => {
   it('should handle an ArrayLike with a mapFn', function (done: MochaDone) {
     this.timeout(300);
 
-    const arrayLike = {
+    const arrayLike: ArrayLike<number> = {
       length: 3,
       0: 1,
       1: 2,
@@ -83,7 +84,7 @@ describe('Observable.from', () => {
   });
 
   it('should handle an ArrayLike with a thisArg', (done: MochaDone) => {
-    const arrayLike = {
+    const arrayLike: ArrayLike<number> = {
       length: 3,
       0: 1,
       1: 2,
@@ -116,7 +117,7 @@ describe('Observable.from', () => {
   });
 
   it('should handle an "observableque" object', (done: MochaDone) => {
-    const observablesque = {};
+    const observablesque: Observablesque<any> = {};
 
     observablesque[Symbol.observable] = () => {
       return {
@@ -137,7 +138,7 @@ describe('Observable.from', () => {
   });
 
   it('should accept scheduler for observableque object', () => {
-    const observablesque = {};
+    const observablesque: Observablesque<any> = <any>{};
 
     observablesque[Symbol.observable] = () => {
       return {
@@ -166,7 +167,7 @@ describe('Observable.from', () => {
   });
 
   it('should handle any iterable thing', (done: MochaDone) => {
-    const iterable = {};
+    const iterable: Iterable<string> = {};
     const iteratorResults = [
       { value: 'one', done: false },
       { value: 'two', done: false },
@@ -195,7 +196,7 @@ describe('Observable.from', () => {
 
   it('should throw for non observable object', () => {
     const r = () => {
-      Observable.from({}).subscribe();
+      Observable.from(<any>{}).subscribe();
     };
 
     expect(r).to.throw();
@@ -212,4 +213,23 @@ describe('Observable.from', () => {
       done();
     });
   });
+
+  it('should return T for ObservableLike objects', () => {
+    type(() => {
+      /* tslint:disable:no-unused-variable */
+      let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
+      let o2: Rx.Observable<string> = Observable.from(<Iterable<string>>{});
+      let o3: Rx.Observable<{ a: string }> = Observable.from(Observable.empty<{ a: string }>());
+      let o4: Rx.Observable<{ b: number }> = Observable.from(new Promise<{b: number}>(resolve => resolve()));
+      /* tslint:enable:no-unused-variable */
+    });
+  });
+
+  it('should return T and map for arrays', () => {
+    type(() => {
+      /* tslint:disable:no-unused-variable */
+      let o1: Rx.Observable<number> = Observable.from(<number[]>[], x => x.toString(), null, Rx.Scheduler.asap);
+      /* tslint:enable:no-unused-variable */
+    });
+  });
 });

spec/observables/zip-spec.ts

@@ -77,7 +77,7 @@ describe('Observable.zip', () => {
 
   describe('with iterables', () => {
     it('should zip them with values', () => {
-      const myIterator = {
+      const myIterator: Iterable<number> = <any>{
         count: 0,
         next: function () {
           return { value: this.count++, done: false };
@@ -103,7 +103,7 @@ describe('Observable.zip', () => {
 
     it('should only call `next` as needed', () => {
       let nextCalled = 0;
-      const myIterator = {
+      const myIterator: Iterable<number> = <any>{
         count: 0,
         next: () => {
           nextCalled++;

spec/operators/mergeMap-spec.ts

@@ -43,7 +43,7 @@ describe('Observable.prototype.mergeMap', () => {
   it('should map values to constant rejected promises and merge', (done: MochaDone) => {
     const source = Rx.Observable.from([4, 3, 2, 1]);
     const project = function (value) {
-      return Observable.from(Promise.reject(42));
+      return Observable.from(Promise.reject<number>(42));
     };
 
     source.mergeMap(project).subscribe(
@@ -82,11 +82,11 @@ describe('Observable.prototype.mergeMap', () => {
   it('should map values to rejected promises and merge', (done: MochaDone) => {
     const source = Rx.Observable.from([4, 3, 2, 1]);
     const project = function (value, index) {
-      return Observable.from(Promise.reject('' + value + '-' + index));
+      return Observable.from(Promise.reject<string>('' + value + '-' + index));
     };
 
     source.mergeMap(project).subscribe(
-      (x: number) => {
+      (x: string) => {
         done(new Error('Subscriber next handler not supposed to be called.'));
       },
       (err: any) => {

spec/operators/zip-spec.ts

@@ -77,7 +77,7 @@ describe('Observable.prototype.zip', () => {
 
   describe('with iterables', () => {
     it('should zip them with values', () => {
-      const myIterator = {
+      const myIterator: Iterable<number> = <any>{
         count: 0,
         next: function () {
           return { value: this.count++, done: false };
@@ -102,7 +102,7 @@ describe('Observable.prototype.zip', () => {
 
     it('should only call `next` as needed', () => {
       let nextCalled = 0;
-      const myIterator = {
+      const myIterator: Iterable<number> = <any>{
         count: 0,
         next: function () {
           nextCalled++;

src/observable/ArrayObservable.ts

@@ -24,7 +24,14 @@ export class ArrayObservable<T> extends Observable<T> {
    * @name of
    * @owner Observable
    */
-  static of<T>(...array: Array<T | Scheduler>): Observable<T> {
+   static of<T>(item1: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(item1: T, item2: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(item1: T, item2: T, item3: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(item1: T, item2: T, item3: T, item4: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(item1: T, item2: T, item3: T, item4: T, item5: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(item1: T, item2: T, item3: T, item4: T, item5: T, item6: T, scheduler?: Scheduler): Observable<T>;
+   static of<T>(...array: Array<T | Scheduler>): Observable<T>;
+   static of<T>(...array: Array<T | Scheduler>): Observable<T> {
     let scheduler = <Scheduler>array[array.length - 1];
     if (isScheduler(scheduler)) {
       array.pop();

src/observable/FromObservable.ts

@@ -36,7 +36,12 @@ export class FromObservable<T> extends Observable<T> {
    * @name from
    * @owner Observable
    */
-  static create<T>(ish: any, mapFnOrScheduler?: Scheduler | ((x: any, y: number) => T), thisArg?: any, lastScheduler?: Scheduler): Observable<T> {
+  static create<T>(ish: ObservableInput<T>, scheduler?: Scheduler): Observable<T>;
+  static create<T, R>(ish: ArrayLike<T>, mapFn: (x: any, y: number) => R, thisArg?: any, scheduler?: Scheduler): Observable<R>;
+  static create<T>(ish: ObservableInput<T>,
+                   mapFnOrScheduler?: Scheduler | ((x: any, y: number) => T),
+                   thisArg?: any,
+                   lastScheduler?: Scheduler): Observable<T> {
     let scheduler: Scheduler = null;
     let mapFn: (x: any, i: number) => T = null;
     if (isFunction(mapFnOrScheduler)) {

src/util/subscribeToResult.ts

@@ -2,7 +2,7 @@ import {root} from './root';
 import {isArray} from './isArray';
 import {isPromise} from './isPromise';
 import {Subscriber} from '../Subscriber';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {$$iterator} from '../symbol/iterator';
 import {$$observable} from '../symbol/observable';
 import {Subscription} from '../Subscription';
@@ -12,16 +12,20 @@ import {OuterSubscriber} from '../OuterSubscriber';
 export function subscribeToResult<T, R>(outerSubscriber: OuterSubscriber<T, R>,
                                         result: any,
                                         outerValue?: T,
-                                        outerIndex?: number): Subscription {
-  let destination: Subscriber<R> = new InnerSubscriber(outerSubscriber, outerValue, outerIndex);
+                                        outerIndex?: number): Subscription;
+export function subscribeToResult<T>(outerSubscriber: OuterSubscriber<any, any>,
+                                     result: ObservableInput<T>,
+                                     outerValue?: T,
+                                     outerIndex?: number): Subscription {
+  let destination: Subscriber<any> = new InnerSubscriber(outerSubscriber, outerValue, outerIndex);
 
   if (destination.isUnsubscribed) {
     return;
   }
 
   if (result instanceof Observable) {
     if (result._isScalar) {
-      destination.next(result.value);
+      destination.next((<any>result).value);
       destination.complete();
       return;
     } else {
@@ -38,9 +42,9 @@ export function subscribeToResult<T, R>(outerSubscriber: OuterSubscriber<T, R>,
     }
   } else if (isPromise(result)) {
     result.then(
-      (value: any) => {
+      (value) => {
         if (!destination.isUnsubscribed) {
-          destination.next(value);
+          destination.next(<any>value);
           destination.complete();
         }
       },
@@ -52,8 +56,8 @@ export function subscribeToResult<T, R>(outerSubscriber: OuterSubscriber<T, R>,
     });
     return destination;
   } else if (typeof result[$$iterator] === 'function') {
-    for (let item of result) {
-      destination.next(item);
+    for (let item of <any>result) {
+      destination.next(<any>item);
       if (destination.isUnsubscribed) {
         break;
       }