rxjs - npm Package Compare versions

Comparing version 5.0.0-alpha.13 to 5.0.0-alpha.14

CoreOperators.d.ts

@@ -20,3 +20,3 @@ import { Observable } from './Observable';
     concatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-    count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
+    count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
     dematerialize?: () => Observable<any>;
@@ -27,8 +27,8 @@ debounce?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
     delay?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-    distinctUntilChanged?: (compare?: (x: T, y: T) => boolean, thisArg?: any) => Observable<T>;
+    distinctUntilChanged?: (compare?: (x: T, y: T) => boolean) => Observable<T>;
     do?: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
     expand?: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
     filter?: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
-    finally?: (ensure: () => void, thisArg?: any) => Observable<T>;
-    first?: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R, thisArg?: any, defaultValue?: any) => Observable<T> | Observable<R>;
+    finally?: (finallySelector: () => void) => Observable<T>;
+    first?: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
     flatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
@@ -38,3 +38,3 @@ flatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
     ignoreElements?: () => Observable<T>;
-    last?: <R>(predicate?: (value: T, index: number) => boolean, resultSelector?: (value: T, index: number) => R, thisArg?: any, defaultValue?: any) => Observable<T> | Observable<R>;
+    last?: <R>(predicate?: (value: T, index: number) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
     every?: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
@@ -63,6 +63,6 @@ map?: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
     share?: () => Observable<T>;
-    single?: (predicate?: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
+    single?: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
     skip?: (count: number) => Observable<T>;
     skipUntil?: (notifier: Observable<any>) => Observable<T>;
-    skipWhile?: (predicate: (x: T, index: number) => boolean, thisArg?: any) => Observable<T>;
+    skipWhile?: (predicate: (x: T, index: number) => boolean) => Observable<T>;
     startWith?: (x: T) => Observable<T>;
@@ -69,0 +69,0 @@ subscribeOn?: (scheduler: Scheduler, delay?: number) => Observable<T>;

Observable.d.ts

@@ -60,7 +60,8 @@ import { Observer } from './Observer';
      * @param {Function} next a handler for each value emitted by the observable
-     * @param {PromiseConstructor} PromiseCtor? a constructor function used to instantiate the Promise
+     * @param {any} [thisArg] a `this` context for the `next` handler function
+     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
      * @returns {Promise} a promise that either resolves on observable completion or
      *  rejects with the handled error
      */
-    forEach(next: (value: T) => void, PromiseCtor?: PromiseConstructor): Promise<void>;
+    forEach(next: (value: T) => void, thisArg: any, PromiseCtor?: PromiseConstructor): Promise<void>;
     _subscribe(subscriber: Subscriber<any>): Subscription<T> | Function | void;
@@ -98,3 +99,3 @@ static bindCallback: <T>(callbackFunc: Function, selector?: Function, scheduler?: Scheduler) => Function;
     concatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-    count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
+    count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
     dematerialize: () => Observable<any>;
@@ -105,7 +106,7 @@ debounce: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
     delay: (delay: number, scheduler?: Scheduler) => Observable<T>;
-    distinctUntilChanged: (compare?: (x: T, y: T) => boolean, thisArg?: any) => Observable<T>;
+    distinctUntilChanged: (compare?: (x: T, y: T) => boolean) => Observable<T>;
     do: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
     expand: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
     filter: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
-    finally: (ensure: () => void, thisArg?: any) => Observable<T>;
+    finally: (finallySelector: () => void) => Observable<T>;
     first: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R, thisArg?: any, defaultValue?: any) => Observable<T> | Observable<R>;
@@ -140,3 +141,3 @@ flatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
     share: () => Observable<T>;
-    single: (predicate?: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
+    single: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
     skip: (count: number) => Observable<T>;
@@ -148,5 +149,5 @@ skipUntil: (notifier: Observable<any>) => Observable<T>;
     switch: <R>() => Observable<R>;
-    switchFirst: <T>() => Observable<T>;
+    exhaust: <T>() => Observable<T>;
     switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-    switchFirstMap: <T, R, R2>(project: (x: T, ix: number) => Observable<R>, rSelector?: (x: T, y: R, ix: number, iy: number) => R2) => Observable<R>;
+    exhaustMap: <T, R, R2>(project: (x: T, ix: number) => Observable<R>, rSelector?: (x: T, y: R, ix: number, iy: number) => R2) => Observable<R>;
     switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
@@ -153,0 +154,0 @@ take: (count: number) => Observable<T>;

Observable.js

@@ -80,8 +80,8 @@ var Subscriber_1 = require('./Subscriber');
      * @param {Function} next a handler for each value emitted by the observable
-     * @param {PromiseConstructor} PromiseCtor? a constructor function used to instantiate the Promise
+     * @param {any} [thisArg] a `this` context for the `next` handler function
+     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
      * @returns {Promise} a promise that either resolves on observable completion or
      *  rejects with the handled error
      */
-    Observable.prototype.forEach = function (next, PromiseCtor) {
-        var _this = this;
+    Observable.prototype.forEach = function (next, thisArg, PromiseCtor) {
         if (!PromiseCtor) {
@@ -98,5 +98,21 @@ if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
         }
-        return new PromiseCtor(function (resolve, reject) {
-            _this.subscribe(next, reject, resolve);
-        });
+        var nextHandler;
+        if (thisArg) {
+            nextHandler = function nextHandlerFn(value) {
+                var _a = nextHandlerFn, thisArg = _a.thisArg, next = _a.next;
+                return next.call(thisArg, value);
+            };
+            nextHandler.thisArg = thisArg;
+            nextHandler.next = next;
+        }
+        else {
+            nextHandler = next;
+        }
+        var promiseCallback = function promiseCallbackFn(resolve, reject) {
+            var _a = promiseCallbackFn, source = _a.source, nextHandler = _a.nextHandler;
+            source.subscribe(nextHandler, reject, resolve);
+        };
+        promiseCallback.source = this;
+        promiseCallback.nextHandler = nextHandler;
+        return new PromiseCtor(promiseCallback);
     };
@@ -103,0 +119,0 @@ Observable.prototype._subscribe = function (subscriber) {

operator/count.d.ts

@@ -12,6 +12,5 @@ import { Observable } from '../Observable';
  *   - `source`: the source observable instance itself.
- * @param {any} [thisArg] the optional `this` context to use in the `predicate` function
  * @returns {Observable} an observable of one number that represents the count as described
  * above
  */
-export declare function count<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
+export declare function count<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<number>;

operator/count.js

@@ -9,3 +9,2 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
 /**
@@ -21,18 +20,16 @@ * Returns an observable of a single number that represents the number of items that either:
  *   - `source`: the source observable instance itself.
- * @param {any} [thisArg] the optional `this` context to use in the `predicate` function
  * @returns {Observable} an observable of one number that represents the count as described
  * above
  */
-function count(predicate, thisArg) {
-    return this.lift(new CountOperator(predicate, thisArg, this));
+function count(predicate) {
+    return this.lift(new CountOperator(predicate, this));
 }
 exports.count = count;
 var CountOperator = (function () {
-    function CountOperator(predicate, thisArg, source) {
+    function CountOperator(predicate, source) {
         this.predicate = predicate;
-        this.thisArg = thisArg;
         this.source = source;
     }
     CountOperator.prototype.call = function (subscriber) {
-        return new CountSubscriber(subscriber, this.predicate, this.thisArg, this.source);
+        return new CountSubscriber(subscriber, this.predicate, this.source);
     };
@@ -43,11 +40,8 @@ return CountOperator;
     __extends(CountSubscriber, _super);
-    function CountSubscriber(destination, predicate, thisArg, source) {
+    function CountSubscriber(destination, predicate, source) {
         _super.call(this, destination);
-        this.thisArg = thisArg;
+        this.predicate = predicate;
         this.source = source;
         this.count = 0;
         this.index = 0;
-        if (typeof predicate === 'function') {
-            this.predicate = bindCallback_1.bindCallback(predicate, thisArg, 3);
-        }
     }
@@ -54,0 +48,0 @@ CountSubscriber.prototype._next = function (value) {

operator/distinctUntilChanged.d.ts

@@ -1,1 +0,1 @@
-export declare function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean, thisArg?: any): any;
+export declare function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean): any;

operator/distinctUntilChanged.js

@@ -9,7 +9,4 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
-function distinctUntilChanged(compare, thisArg) {
-    return this.lift(new DistinctUntilChangedOperator(thisArg ?
-        bindCallback_1.bindCallback(compare, thisArg, 2) :
-        compare));
+function distinctUntilChanged(compare) {
+    return this.lift(new DistinctUntilChangedOperator(compare));
 }
@@ -16,0 +13,0 @@ exports.distinctUntilChanged = distinctUntilChanged;

operator/every.js

@@ -12,3 +12,2 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
 function every(predicate, thisArg) {
@@ -18,3 +17,3 @@ var source = this;
     if (source._isScalar) {
-        result = tryCatch_1.tryCatch(predicate)(source.value, 0, source);
+        result = tryCatch_1.tryCatch(predicate).call(thisArg || this, source.value, 0, source);
         if (result === errorObject_1.errorObject) {
@@ -29,3 +28,3 @@ return new throw_1.ErrorObservable(errorObject_1.errorObject.e, source.scheduler);
         var array = source.array;
-        var result_1 = tryCatch_1.tryCatch(function (array, predicate) { return array.every(predicate); })(array, predicate);
+        var result_1 = tryCatch_1.tryCatch(function (array, predicate, thisArg) { return array.every(predicate, thisArg); })(array, predicate, thisArg);
         if (result_1 === errorObject_1.errorObject) {
@@ -56,9 +55,6 @@ return new throw_1.ErrorObservable(errorObject_1.errorObject.e, source.scheduler);
         _super.call(this, destination);
+        this.predicate = predicate;
         this.thisArg = thisArg;
         this.source = source;
-        this.predicate = undefined;
         this.index = 0;
-        if (typeof predicate === 'function') {
-            this.predicate = bindCallback_1.bindCallback(predicate, thisArg, 3);
-        }
     }
@@ -70,7 +66,3 @@ EverySubscriber.prototype.notifyComplete = function (everyValueMatch) {
     EverySubscriber.prototype._next = function (value) {
-        var predicate = this.predicate;
-        if (predicate === undefined) {
-            this.destination.error(new TypeError('predicate must be a function'));
-        }
-        var result = tryCatch_1.tryCatch(predicate)(value, this.index++, this.source);
+        var result = tryCatch_1.tryCatch(this.predicate).call(this.thisArg || this, value, this.index++, this.source);
         if (result === errorObject_1.errorObject) {
@@ -77,0 +69,0 @@ this.destination.error(result.e);

operator/extended/distinctUntilKeyChanged.d.ts

@@ -1,1 +0,1 @@
-export declare function distinctUntilKeyChanged<T>(key: string, compare?: (x: any, y: any) => boolean, thisArg?: any): any;
+export declare function distinctUntilKeyChanged<T>(key: string, compare?: (x: any, y: any) => boolean): any;

operator/extended/distinctUntilKeyChanged.js

 var distinctUntilChanged_1 = require('../distinctUntilChanged');
-function distinctUntilKeyChanged(key, compare, thisArg) {
+function distinctUntilKeyChanged(key, compare) {
     return distinctUntilChanged_1.distinctUntilChanged.call(this, function (x, y) {
         if (compare) {
-            return compare.call(thisArg, x[key], y[key]);
+            return compare(x[key], y[key]);
         }
@@ -7,0 +7,0 @@ return x[key] === y[key];

operator/extended/find-support.d.ts

@@ -13,6 +13,6 @@ import { Operator } from '../../Operator';
 export declare class FindValueSubscriber<T> extends Subscriber<T> {
+    private predicate;
     private source;
     private yieldIndex;
     private thisArg;
-    private predicate;
     private index;
@@ -19,0 +19,0 @@ constructor(destination: Subscriber<T>, predicate: (value: T, index: number, source: Observable<T>) => boolean, source: Observable<T>, yieldIndex: boolean, thisArg?: any);

operator/extended/find-support.js

@@ -9,3 +9,2 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../../util/errorObject');
-var bindCallback_1 = require('../../util/bindCallback');
 var FindValueOperator = (function () {
@@ -28,2 +27,3 @@ function FindValueOperator(predicate, source, yieldIndex, thisArg) {
         _super.call(this, destination);
+        this.predicate = predicate;
         this.source = source;
@@ -33,5 +33,2 @@ this.yieldIndex = yieldIndex;
         this.index = 0;
-        if (typeof predicate === 'function') {
-            this.predicate = bindCallback_1.bindCallback(predicate, thisArg, 3);
-        }
     }
@@ -44,5 +41,5 @@ FindValueSubscriber.prototype.notifyComplete = function (value) {
     FindValueSubscriber.prototype._next = function (value) {
-        var predicate = this.predicate;
+        var _a = this, predicate = _a.predicate, thisArg = _a.thisArg;
         var index = this.index++;
-        var result = tryCatch_1.tryCatch(predicate)(value, index, this.source);
+        var result = tryCatch_1.tryCatch(predicate).call(thisArg || this, value, index, this.source);
         if (result === errorObject_1.errorObject) {
@@ -49,0 +46,0 @@ this.destination.error(result.e);

operator/extended/find.js

 var find_support_1 = require('./find-support');
 function find(predicate, thisArg) {
+    if (typeof predicate !== 'function') {
+        throw new TypeError('predicate is not a function');
+    }
     return this.lift(new find_support_1.FindValueOperator(predicate, this, false, thisArg));
@@ -4,0 +7,0 @@ }

operator/filter.js

@@ -9,3 +9,2 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
 /**
@@ -26,6 +25,7 @@ * Similar to the well-known `Array.prototype.filter` method, this operator filters values down to a set
     function FilterOperator(select, thisArg) {
-        this.select = bindCallback_1.bindCallback(select, thisArg, 2);
+        this.select = select;
+        this.thisArg = thisArg;
     }
     FilterOperator.prototype.call = function (subscriber) {
-        return new FilterSubscriber(subscriber, this.select);
+        return new FilterSubscriber(subscriber, this.select, this.thisArg);
     };
@@ -36,4 +36,5 @@ return FilterOperator;
     __extends(FilterSubscriber, _super);
-    function FilterSubscriber(destination, select) {
+    function FilterSubscriber(destination, select, thisArg) {
         _super.call(this, destination);
+        this.thisArg = thisArg;
         this.count = 0;
@@ -43,3 +44,3 @@ this.select = select;
     FilterSubscriber.prototype._next = function (x) {
-        var result = tryCatch_1.tryCatch(this.select)(x, this.count++);
+        var result = tryCatch_1.tryCatch(this.select).call(this.thisArg || this, x, this.count++);
         if (result === errorObject_1.errorObject) {
@@ -46,0 +47,0 @@ this.destination.error(errorObject_1.errorObject.e);

operator/finally.d.ts

@@ -1,1 +0,1 @@
-export declare function _finally<T>(finallySelector: () => void, thisArg?: any): any;
+export declare function _finally<T>(finallySelector: () => void): any;

operator/finally.js

@@ -8,7 +8,4 @@ var __extends = (this && this.__extends) || function (d, b) {
 var Subscription_1 = require('../Subscription');
-var bindCallback_1 = require('../util/bindCallback');
-function _finally(finallySelector, thisArg) {
-    return this.lift(new FinallyOperator(thisArg ?
-        bindCallback_1.bindCallback(finallySelector, thisArg, 2) :
-        finallySelector));
+function _finally(finallySelector) {
+    return this.lift(new FinallyOperator(finallySelector));
 }
@@ -15,0 +12,0 @@ exports._finally = _finally;

operator/map.js

@@ -9,3 +9,2 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
 /**
@@ -20,2 +19,5 @@ * Similar to the well known `Array.prototype.map` function, this operator
 function map(project, thisArg) {
+    if (typeof project !== 'function') {
+        throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
+    }
     return this.lift(new MapOperator(project, thisArg));
@@ -26,6 +28,7 @@ }
     function MapOperator(project, thisArg) {
-        this.project = bindCallback_1.bindCallback(project, thisArg, 2);
+        this.project = project;
+        this.thisArg = thisArg;
     }
     MapOperator.prototype.call = function (subscriber) {
-        return new MapSubscriber(subscriber, this.project);
+        return new MapSubscriber(subscriber, this.project, this.thisArg);
     };
@@ -36,9 +39,10 @@ return MapOperator;
     __extends(MapSubscriber, _super);
-    function MapSubscriber(destination, project) {
+    function MapSubscriber(destination, project, thisArg) {
         _super.call(this, destination);
+        this.project = project;
+        this.thisArg = thisArg;
         this.count = 0;
-        this.project = project;
     }
     MapSubscriber.prototype._next = function (x) {
-        var result = tryCatch_1.tryCatch(this.project)(x, this.count++);
+        var result = tryCatch_1.tryCatch(this.project).call(this.thisArg || this, x, this.count++);
         if (result === errorObject_1.errorObject) {
@@ -45,0 +49,0 @@ this.error(errorObject_1.errorObject.e);

operator/single.d.ts

 import { Observable } from '../Observable';
-export declare function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+export declare function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T>;

operator/single.js

@@ -9,16 +9,14 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
 var EmptyError_1 = require('../util/EmptyError');
-function single(predicate, thisArg) {
-    return this.lift(new SingleOperator(predicate, thisArg, this));
+function single(predicate) {
+    return this.lift(new SingleOperator(predicate, this));
 }
 exports.single = single;
 var SingleOperator = (function () {
-    function SingleOperator(predicate, thisArg, source) {
+    function SingleOperator(predicate, source) {
         this.predicate = predicate;
-        this.thisArg = thisArg;
         this.source = source;
     }
     SingleOperator.prototype.call = function (subscriber) {
-        return new SingleSubscriber(subscriber, this.predicate, this.thisArg, this.source);
+        return new SingleSubscriber(subscriber, this.predicate, this.source);
     };
@@ -29,11 +27,8 @@ return SingleOperator;
     __extends(SingleSubscriber, _super);
-    function SingleSubscriber(destination, predicate, thisArg, source) {
+    function SingleSubscriber(destination, predicate, source) {
         _super.call(this, destination);
-        this.thisArg = thisArg;
+        this.predicate = predicate;
         this.source = source;
         this.seenValue = false;
         this.index = 0;
-        if (typeof predicate === 'function') {
-            this.predicate = bindCallback_1.bindCallback(predicate, thisArg, 3);
-        }
     }
@@ -40,0 +35,0 @@ SingleSubscriber.prototype.applySingleValue = function (value) {

operator/skipWhile.d.ts

 import { Observable } from '../Observable';
-export declare function skipWhile<T>(predicate: (x: T, index: number) => boolean, thisArg?: any): Observable<T>;
+export declare function skipWhile<T>(predicate: (x: T, index: number) => boolean): Observable<T>;

operator/skipWhile.js

@@ -9,10 +9,9 @@ var __extends = (this && this.__extends) || function (d, b) {
 var errorObject_1 = require('../util/errorObject');
-var bindCallback_1 = require('../util/bindCallback');
-function skipWhile(predicate, thisArg) {
-    return this.lift(new SkipWhileOperator(predicate, thisArg));
+function skipWhile(predicate) {
+    return this.lift(new SkipWhileOperator(predicate));
 }
 exports.skipWhile = skipWhile;
 var SkipWhileOperator = (function () {
-    function SkipWhileOperator(predicate, thisArg) {
-        this.predicate = bindCallback_1.bindCallback(predicate, thisArg, 2);
+    function SkipWhileOperator(predicate) {
+        this.predicate = predicate;
     }
@@ -19,0 +18,0 @@ SkipWhileOperator.prototype.call = function (subscriber) {

operator/timeoutWith.js

@@ -32,3 +32,4 @@ var __extends = (this && this.__extends) || function (d, b) {
     function TimeoutWithSubscriber(destination, absoluteTimeout, waitFor, withObservable, scheduler) {
-        _super.call(this, destination);
+        _super.call(this, null);
+        this.destination = destination;
         this.absoluteTimeout = absoluteTimeout;
@@ -39,6 +40,6 @@ this.waitFor = waitFor;
         this.timeoutSubscription = undefined;
-        this.timedOut = false;
         this.index = 0;
         this._previousIndex = 0;
         this._hasCompleted = false;
+        destination.add(this);
         this.scheduleTimeout();
@@ -75,25 +76,21 @@ }
     TimeoutWithSubscriber.prototype._next = function (value) {
-        if (!this.timedOut) {
-            this.destination.next(value);
-            if (!this.absoluteTimeout) {
-                this.scheduleTimeout();
-            }
+        this.destination.next(value);
+        if (!this.absoluteTimeout) {
+            this.scheduleTimeout();
         }
     };
     TimeoutWithSubscriber.prototype._error = function (err) {
-        if (!this.timedOut) {
-            this.destination.error(err);
-            this._hasCompleted = true;
-        }
+        this.destination.error(err);
+        this._hasCompleted = true;
     };
     TimeoutWithSubscriber.prototype._complete = function () {
-        if (!this.timedOut) {
-            this.destination.complete();
-            this._hasCompleted = true;
-        }
+        this.destination.complete();
+        this._hasCompleted = true;
     };
     TimeoutWithSubscriber.prototype.handleTimeout = function () {
-        var withObservable = this.withObservable;
-        this.timedOut = true;
-        this.add(this.timeoutSubscription = subscribeToResult_1.subscribeToResult(this, withObservable));
+        if (!this.isUnsubscribed) {
+            var withObservable = this.withObservable;
+            this.unsubscribe();
+            this.destination.add(this.timeoutSubscription = subscribeToResult_1.subscribeToResult(this, withObservable));
+        }
     };
@@ -100,0 +97,0 @@ return TimeoutWithSubscriber;

package.json

 {
-  "engines": {
-    "npm": ">=2.0.0"
+  "repository": {
+    "type": "git",
+    "url": "[e-mail]:ReactiveX/RxJS.git"
   },
-  "main": "Rx.js",
-  "typings": "Rx.d.ts",
-  "description": "Reactive Extensions for modern JavaScript",
+  "name": "rxjs",
+  "keywords": [
+    "Rx",
+    "RxJS",
+    "ReactiveX",
+    "ReactiveExtensions",
+    "Streams",
+    "Observables",
+    "Observable",
+    "Stream",
+    "ES6",
+    "ES2015"
+  ],
+  "author": "Ben Lesh <[e-mail]>",
+  "homepage": "https://github.com/ReactiveX/RxJS",
+  "bugs": {
+    "url": "https://github.com/ReactiveX/RxJS/issues"
+  },
   "contributors": [
@@ -26,23 +42,2 @@ {
   ],
-  "bugs": {
-    "url": "https://github.com/ReactiveX/RxJS/issues"
-  },
-  "version": "5.0.0-alpha.13",
-  "keywords": [
-    "Rx",
-    "RxJS",
-    "ReactiveX",
-    "ReactiveExtensions",
-    "Streams",
-    "Observables",
-    "Observable",
-    "Stream",
-    "ES6",
-    "ES2015"
-  ],
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "[e-mail]:ReactiveX/RxJS.git"
-  },
   "devDependencies": {
@@ -69,2 +64,3 @@ "benchmark": "1.0.0",
     "markdown-doctest": "^0.3.0",
+    "madge": "^0.5.3",
     "mkdirp": "^0.5.1",
@@ -76,3 +72,3 @@ "platform": "1.3.0",
     "rx": "latest",
-    "tslint": "2.5.0",
+    "tslint": "3.2.0-dev.1",
     "typescript": "1.8.0-dev.20151115",
@@ -82,2 +78,5 @@ "validate-commit-msg": "1.0.0",
   },
+  "typings": "Rx.d.ts",
+  "license": "Apache-2.0",
+  "version": "5.0.0-alpha.14",
   "config": {
@@ -91,5 +90,7 @@ "commitizen": {
   },
-  "author": "Ben Lesh <[e-mail]>",
-  "name": "rxjs",
-  "homepage": "https://github.com/ReactiveX/RxJS"
+  "description": "Reactive Extensions for modern JavaScript",
+  "engines": {
+    "npm": ">=2.0.0"
+  },
+  "main": "Rx.js"
 }

Rx.js

@@ -88,5 +88,3 @@ /* tslint:disable:no-unused-variable */
 require('./add/operator/switch');
-require('./add/operator/switchFirst');
 require('./add/operator/switchMap');
-require('./add/operator/switchFirstMap');
 require('./add/operator/switchMapTo');
@@ -93,0 +91,0 @@ require('./add/operator/take');

Rx.KitchenSink.d.ts

@@ -8,3 +8,3 @@ import { Subject } from './Subject';
     elementAt?: (index: number, defaultValue?: any) => Observable<T>;
-    distinctUntilKeyChanged?: (key: string, compare?: (x: any, y: any) => boolean, thisArg?: any) => Observable<T>;
+    distinctUntilKeyChanged?: (key: string, compare?: (x: any, y: any) => boolean) => Observable<T>;
     find?: (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<T>;
@@ -16,4 +16,4 @@ findIndex?: (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
     mergeScan?: <T, R>(project: (acc: R, x: T) => Observable<R>, seed: R, concurrent?: number) => Observable<R>;
-    switchFirst?: () => Observable<T>;
-    switchFirstMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+    exhaust?: () => Observable<T>;
+    exhaustMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
 }
@@ -20,0 +20,0 @@ import { Subscription } from './Subscription';

Rx.KitchenSink.js

@@ -50,2 +50,4 @@ /* tslint:disable:no-unused-variable */
 require('./add/operator/extended/elementAt');
+require('./add/operator/exhaust');
+require('./add/operator/exhaustMap');
 require('./add/operator/expand');
@@ -52,0 +54,0 @@ require('./add/operator/filter');

util/SymbolShim.d.ts

 export declare function polyfillSymbol(root: any): any;
+export declare function ensureFor(Symbol: any): void;
 export declare function ensureSymbol(root: any): any;
@@ -3,0 +4,0 @@ export declare function symbolForPolyfill(key: any): string;

util/SymbolShim.js

@@ -6,9 +6,17 @@ var root_1 = require('./root');
     ensureObservable(Symbol);
+    ensureFor(Symbol);
     return Symbol;
 }
 exports.polyfillSymbol = polyfillSymbol;
+function ensureFor(Symbol) {
+    if (!Symbol.for) {
+        Symbol.for = symbolForPolyfill;
+    }
+}
+exports.ensureFor = ensureFor;
+var id = 0;
 function ensureSymbol(root) {
     if (!root.Symbol) {
-        root.Symbol = {
-            for: symbolForPolyfill
+        root.Symbol = function symbolFuncPolyfill(description) {
+            return "@@Symbol(" + description + "):" + id++;
         };
@@ -15,0 +23,0 @@ }

No alert changes

Worsened metrics

Total package byte prevSize

849488

decreased by-0.3%

Dev dependency count

31

increased by3.33%

Number of package files

840

decreased by-0.36%

Lines of code

10749

decreased by-0.26%

No dependency changes