phadej/menrva

File rx.lite.js has 3735 lines of code (exceeds 250 allowed). Consider refactoring.

Open

// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

;(function (undefined) {

  var objectTypes = {

Function Scheduler has 132 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Scheduler = Rx.Scheduler = (function () {

        function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) {
            this.now = now;
            this._schedule = schedule;

Function ReplaySubject has 111 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var ReplaySubject = Rx.ReplaySubject = (function (_super) {

        function RemovableDisposable (subject, observer) {
            this.subject = subject;
            this.observer = observer;

Function ControlledSubject has 105 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var ControlledSubject = Rx.ControlledSubject = (function (_super) {

        function subscribe (observer) {
            return this.subject.subscribe(observer);
        }

Function deepEquals has 92 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function deepEquals(a, b, stackA, stackB) {
    // exit early for identical values
    if (a === b) {
      // treat `+0` vs. `-0` as not equal
      return a !== 0 || (1 / a == 1 / b);

Function AsyncSubject has 83 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var AsyncSubject = Rx.AsyncSubject = (function (_super) {

        function subscribe(observer) {
            checkDisposed.call(this);
            

Function BehaviorSubject has 69 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var BehaviorSubject = Rx.BehaviorSubject = (function (_super) {
        function subscribe(observer) {
            checkDisposed.call(this);
            if (!this.isStopped) {
                this.observers.push(observer);

Function Subject has 65 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var Subject = Rx.Subject = (function (_super) {
        function subscribe(observer) {
            checkDisposed.call(this);
            if (!this.isStopped) {
                this.observers.push(observer);

Function PausableBufferedObservable has 63 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var PausableBufferedObservable = (function (_super) {

    inherits(PausableBufferedObservable, _super);

    function subscribe(observer) {

Function delay has 63 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.delay = function (dueTime, scheduler) {
        scheduler || (scheduler = timeoutScheduler);
        var source = this;  
        return new AnonymousObservable(function (observer) {
            var active = false,

Function timeoutWithSelector has 61 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.timeoutWithSelector = function (firstTimeout, timeoutdurationSelector, other) {
        if (arguments.length === 1) {
            timeoutdurationSelector = firstTimeout;
            var firstTimeout = observableNever();
        }

Function ScheduledObserver has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var ScheduledObserver = Rx.internals.ScheduledObserver = (function (_super) {
    inherits(ScheduledObserver, _super);

    function ScheduledObserver(scheduler, observer) {
      _super.call(this);

Function currentThread has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var currentThreadScheduler = Scheduler.currentThread = (function () {
        var queue;

        function runTrampoline (q) {
            var item;

Function combineLatest has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var combineLatest = Observable.combineLatest = function () {
    var args = slice.call(arguments), resultSelector = args.pop();
    
    if (Array.isArray(args[0])) {
      args = args[0];

Function AutoDetachObserver has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var AutoDetachObserver = (function (_super) {
        inherits(AutoDetachObserver, _super);

        function AutoDetachObserver(observer) {
            _super.call(this);

Function delayWithSelector has 47 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.delayWithSelector = function (subscriptionDelay, delayDurationSelector) {
        var source = this, subDelay, selector;
        if (typeof subscriptionDelay === 'function') {
            selector = subscriptionDelay;
        } else {

Function zip has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  observableProto.zip = function () {
    if (Array.isArray(arguments[0])) {
      return zipArray.apply(this, arguments);
    }
    var parent = this, sources = slice.call(arguments), resultSelector = sources.pop();

Function catchException has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  Enumerable.prototype.catchException = function () {
    var sources = this;
    return new AnonymousObservable(function (observer) {
      var e;
      try {

Function throttleWithSelector has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.throttleWithSelector = function (throttleDurationSelector) {
        var source = this;
        return new AnonymousObservable(function (observer) {
            var value, hasValue = false, cancelable = new SerialDisposable(), id = 0, subscription = source.subscribe(function (x) {
                var throttle;

Function ConnectableObservable has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var ConnectableObservable = Rx.ConnectableObservable = (function (_super) {
        inherits(ConnectableObservable, _super);

        /**
         * @constructor

Function merge has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.merge = function (maxConcurrentOrOther) {
        if (typeof maxConcurrentOrOther !== 'number') {
            return observableMerge(this, maxConcurrentOrOther);
        }
        var sources = this;

Consider simplifying this complex logical expression.

Open

      if (ctorA != ctorB &&
            !(hasOwnProperty.call(a, 'constructor') && hasOwnProperty.call(b, 'constructor')) &&
            !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
            ('constructor' in a && 'constructor' in b)
          ) {

Function zipArray has 41 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    Observable.zipArray = function () {
        var sources = argsOrArray(arguments, 0);
        return new AnonymousObservable(function (observer) {
            var n = sources.length,
              queues = arrayInitialize(n, function () { return []; }),

Function timeout has 41 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  observableProto.timeout = function (dueTime, other, scheduler) {
    other || (other = observableThrow(new Error('Timeout')));
    scheduler || (scheduler = timeoutScheduler);
    
    var source = this, schedulerMethod = dueTime instanceof Date ?

Function doAction has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto['do'] = observableProto.doAction = function (observerOrOnNext, onError, onCompleted) {
        var source = this, onNextFunc;
        if (typeof observerOrOnNext === 'function') {
            onNextFunc = observerOrOnNext;
        } else {

Function subscribe has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function subscribe(observer) {
      var q = [], previous = true;
      
      var subscription =  
        combineLatestSource(

Function combineLatestSource has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function combineLatestSource(source, subject, resultSelector) {
    return new AnonymousObservable(function (observer) {
      var n = 2,
        hasValue = [false, false],
        hasValueAll = false,

Function AnonymousObservable has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var AnonymousObservable = Rx.AnonymousObservable = (function (__super__) {
    inherits(AnonymousObservable, __super__);

    // Fix subscriber to check for undefined or function returned to decorate as Disposable
    function fixSubscriber(subscriber) {

Function concat has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  Enumerable.prototype.concat = function () {
    var sources = this;
    return new AnonymousObservable(function (observer) {
      var e;
      try {

Function RefCountDisposable has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var RefCountDisposable = Rx.RefCountDisposable = (function () {

        function InnerDisposable(disposable) {
            this.disposable = disposable;
            this.disposable.count++;

Function switchLatest has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto['switch'] = observableProto.switchLatest = function () {
        var sources = this;
        return new AnonymousObservable(function (observer) {
            var hasLatest = false,
                innerSubscription = new SerialDisposable(),

Function BooleanDisposable has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var BooleanDisposable = (function () {
        function BooleanDisposable (isSingle) {
            this.isSingle = isSingle;
            this.isDisposed = false;
            this.current = null;

Function scan has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.scan = function () {
        var hasSeed = false, seed, accumulator, source = this;
        if (arguments.length === 2) {
            hasSeed = true;
            seed = arguments[0];

Function PausableObservable has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var PausableObservable = (function (_super) {

    inherits(PausableObservable, _super);

    function subscribe(observer) {

Function AbstractObserver has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    var AbstractObserver = Rx.internals.AbstractObserver = (function (_super) {
        inherits(AbstractObserver, _super);

        /**
         * Creates a new observer in a non-stopped state.

Function generateWithRelativeTime has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    Observable.generateWithRelativeTime = function (initialState, condition, iterate, resultSelector, timeSelector, scheduler) {
        scheduler || (scheduler = timeoutScheduler);
        return new AnonymousObservable(function (observer) {
            var first = true,
                hasResult = false,

Function timeout has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  var timeoutScheduler = Scheduler.timeout = (function () {

    function scheduleNow(state, action) {
        var scheduler = this,
          disposable = new SingleAssignmentDisposable();

Function keysIn has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function keysIn(object) {
    var result = [];
    if (!isObject(object)) {
      return result;
    }

Function fromNodeCallback has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    Observable.fromNodeCallback = function (func, scheduler, context, selector) {
        scheduler || (scheduler = immediateScheduler);
        return function () {
            var args = slice.call(arguments, 0);

Function fromEvent has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  Observable.fromEvent = function (element, eventName, selector) {
    if (ember) {
      return fromEventPattern(
        function (h) { Ember.addListener(element, eventName, h); },
        function (h) { Ember.removeListener(element, eventName, h); },

Function distinctUntilChanged has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    observableProto.distinctUntilChanged = function (keySelector, comparer) {
        var source = this;
        keySelector || (keySelector = identity);
        comparer || (comparer = defaultComparer);
        return new AnonymousObservable(function (observer) {

Function AnonymousObservable has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function AnonymousObservable(subscribe) {
      if (!(this instanceof AnonymousObservable)) {
        return new AnonymousObservable(subscribe);
      }

Function fromCallback has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    Observable.fromCallback = function (func, scheduler, context, selector) {
        scheduler || (scheduler = immediateScheduler);
        return function () {
            var args = slice.call(arguments, 0);

Function generate has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    Observable.generate = function (initialState, condition, iterate, resultSelector, scheduler) {
        scheduler || (scheduler = currentThreadScheduler);
        return new AnonymousObservable(function (observer) {
            var first = true, state = initialState;
            return scheduler.scheduleRecursive(function (self) {

Function cancelable has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
        if (isDisposed) { return; }

        var currentItem;
        try {

Consider simplifying this complex logical expression.

Open

    if (a === a && (a == null || b == null ||
        (type != 'function' && type != 'object' && otherType != 'function' && otherType != 'object'))) {
      return false;
    }

Function generateWithRelativeTime has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    Observable.generateWithRelativeTime = function (initialState, condition, iterate, resultSelector, timeSelector, scheduler) {

Function ScheduledItem has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    var ScheduledItem = Rx.internals.ScheduledItem = function (scheduler, state, action, dueTime, comparer) {

Function generate has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    Observable.generate = function (initialState, condition, iterate, resultSelector, scheduler) {

Avoid too many return statements within this function.

Open

        return stackB[length] == b;

Avoid too many return statements within this function.

Open

    return result;

Avoid too many return statements within this function.

Open

        return false;

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    observableProto.selectConcat = observableProto.concatMap = function (selector, resultSelector) {
      if (resultSelector) {
          return this.concatMap(function (x, i) {
            var selectorResult = selector(x, i),
              result = isPromise(selectorResult) ? observableFromPromise(selectorResult) : selectorResult;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    observableProto.selectMany = observableProto.flatMap = function (selector, resultSelector) {
      if (resultSelector) {
          return this.selectMany(function (x, i) {
            var selectorResult = selector(x, i),
              result = isPromise(selectorResult) ? observableFromPromise(selectorResult) : selectorResult;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function concatMapObserver(onNext, onError, onCompleted) {
      var source = this;
      return new AnonymousObservable(function (observer) {
        var index = 0;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function selectManyObserver(onNext, onError, onCompleted) {
      var source = this;
      return new AnonymousObservable(function (observer) {
        var index = 0;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            onError: function (exception) {
                checkDisposed.call(this);
                if (!this.isStopped) {
                    var os = this.observers.slice(0);
                    this.isStopped = true;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            onError: function (exception) {
                checkDisposed.call(this);
                if (!this.isStopped) {
                    var os = this.observers.slice(0);
                    this.isStopped = true;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

            onError: function (error) {
                checkDisposed.call(this);
                if (!this.isStopped) {
                    var os = this.observers.slice(0);
                    this.isStopped = true;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            onCompleted: function () {
                checkDisposed.call(this);
                if (!this.isStopped) {
                    var os = this.observers.slice(0);
                    this.isStopped = true;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            onCompleted: function () {
                checkDisposed.call(this);
                if (!this.isStopped) {
                    var os = this.observers.slice(0);
                    this.isStopped = true;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    switch (className) {
      case boolClass:
      case dateClass:
        // coerce dates and booleans to numbers, dates to milliseconds and booleans
        // to `1` or `0` treating invalid dates coerced to `NaN` as not equal

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                        if (selector) {
                            try {
                                results = selector(results);
                            } catch (e) {
                                observer.onError(e);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                        if (selector) {
                            try {
                                results = selector(arguments);
                            } catch (err) {
                                observer.onError(err);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        if (first !== index) {
            var temp = this.items[index];
            this.items[index] = this.items[first];
            this.items[first] = temp;
            this.heapify(first);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        if (this.isHigherPriority(index, parent)) {
            var temp = this.items[index];
            this.items[index] = this.items[parent];
            this.items[parent] = temp;
            this.percolate(parent);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      function innerHandler (e) {
        var result = e;
        if (selector) {
          try {
            result = selector(arguments);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        function handler (e) { 
          var results = e;

          if (selector) {
            try {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                    for (var i = 0, len = o.length; i < len; i++) {
                        observer = o[i];
                        observer.onError(error);
                        observer.ensureActive();
                    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                    for (var i = 0, len = o.length; i < len; i++) {
                        observer = o[i];
                        observer.onNext(value);
                        observer.ensureActive();
                    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function concatMap(selector) {
      return this.map(function (x, i) {
        var result = selector(x, i);
        return isPromise(result) ? observableFromPromise(result) : result;
      }).concatAll();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        schedulerProto.scheduleRecursiveWithRelativeAndState = function (state, dueTime, action) {
            return this._scheduleRelative({ first: state, second: action }, dueTime, function (s, p) {
                return invokeRecDate(s, p, 'scheduleWithRelativeAndState');
            });
        };

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function selectMany(selector) {
      return this.select(function (x, i) {
        var result = selector(x, i);
        return isPromise(result) ? observableFromPromise(result) : result;
      }).mergeObservable();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    ScheduledObserver.prototype.next = function (value) {
      var self = this;
      this.queue.push(function () {
        self.observer.onNext(value);
      });

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        schedulerProto.scheduleRecursiveWithAbsolute = function (dueTime, action) {
            return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, function (_action, self) {
                _action(function (dt) {
                    self(_action, dt);
                });

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        schedulerProto.scheduleRecursiveWithAbsoluteAndState = function (state, dueTime, action) {
            return this._scheduleAbsolute({ first: state, second: action }, dueTime, function (s, p) {
                return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
            });
        };

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    ScheduledObserver.prototype.error = function (exception) {
      var self = this;
      this.queue.push(function () {
        self.observer.onError(exception);
      });

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    observableProto.publishLast = function (selector) {
        return !selector ?
            this.multicast(new AsyncSubject()) :
            this.multicast(function () {
                return new AsyncSubject();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        schedulerProto.scheduleRecursiveWithRelative = function (dueTime, action) {
            return this.scheduleRecursiveWithRelativeAndState(action, dueTime, function (_action, self) {
                _action(function (dt) {
                    self(_action, dt);
                });

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    observableProto.publish = function (selector) {
        return !selector ?
            this.multicast(new Subject()) :
            this.multicast(function () {
                return new Subject();

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    PausableBufferedObservable.prototype.resume = function () {
      if (this.isPaused === false){
        return;
      }
      this.isPaused = false;

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    PausableObservable.prototype.pause = function () {
      if (this.isPaused === true){
        return;
      }
      this.isPaused = true;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function PausableBufferedObservable(source, subject) {
      this.source = source;
      this.subject = subject || new Subject();
      this.isPaused = true;
      _super.call(this, subscribe);

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    PausableBufferedObservable.prototype.pause = function () {
      if (this.isPaused === true){
        return;
      }
      this.isPaused = true;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function PausableObservable(source, subject) {
      this.source = source;
      this.subject = subject || new Subject();
      this.isPaused = true;
      _super.call(this, subscribe);

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

    PausableObservable.prototype.resume = function () {
      if (this.isPaused === false){
        return;
      }
      this.isPaused = false;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = (function (super_) {
        inherits(SingleAssignmentDisposable, super_);

        function SingleAssignmentDisposable() {
            super_.call(this, true);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    var SerialDisposable = Rx.SerialDisposable = (function (super_) {
        inherits(SerialDisposable, super_);

        function SerialDisposable() {
            super_.call(this, false);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                while (q.length > 0 && now - q[0].interval >= duration) {
                    observer.onNext(q.shift().value);
                }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (hasValueAll || (hasValueAll = hasValue.every(identity))) {
          try {
            res = resultSelector.apply(null, values);
          } catch (ex) {
            observer.onError(ex);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                while (q.length > 0 && now - q[0].interval >= duration) {
                    observer.onNext(q.shift().value);
                }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (hasValueAll || (hasValueAll = hasValue.every(identity))) {
          try {
            res = resultSelector.apply(null, values);
          } catch (ex) {
            observer.onError(ex);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) {
            this.now = now;
            this._schedule = schedule;
            this._scheduleRelative = scheduleRelative;
            this._scheduleAbsolute = scheduleAbsolute;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            dispose: function () {
                this.isDisposed = true;
                this.observers = null;
                this.exception = null;
                this.value = null;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          sad.setDisposable(source.subscribe(function (x) {
            queues[i].push(x);
            next(i);
          }, observer.onError.bind(observer), function () {
            done(i);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            dispose: function () {
                this.isDisposed = true;
                this.observers = null;
                this.value = null;
                this.exception = null;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        } else {
          try {
            autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
          } catch (e) {
            if (!autoDetachObserver.fail(e)) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                    subscriptions[i].setDisposable(sources[i].subscribe(function (x) {
                        queues[i].push(x);
                        next(i);
                    }, observer.onError.bind(observer), function () {
                        done(i);

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          currentThreadScheduler.schedule(function () {
            try {
              autoDetachObserver.setDisposable(fixSubscriber(subscribe(autoDetachObserver)));
            } catch (e) {
              if (!autoDetachObserver.fail(e)) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        function SchedulePeriodicRecursive(scheduler, state, period, action) {
            this._scheduler = scheduler;
            this._state = state;
            this._period = period;
            this._action = action;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (result) {
        // ensure both objects have the same number of properties
        internalForIn(a, function(value, key, a) {
          if (hasOwnProperty.call(a, key)) {
            // `size` will be `-1` if `a` has more properties than `b`

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                d.setDisposable(throttle.subscribe(function () {
                    if (hasValue && id === currentid) {
                        observer.onNext(value);
                    }
                    hasValue = false;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                }, observer.onError.bind(observer), function () {
                    if (hasValue && id === currentid) {
                        observer.onNext(value);
                    }
                    hasValue = false;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            var n = sources.length,
              queues = arrayInitialize(n, function () { return []; }),
              isDone = arrayInitialize(n, function () { return false; });

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (queues.every(function (x) { return x.length > 0; })) {
          try {
            queuedValues = queues.map(function (x) { return x.shift(); });
            res = resultSelector.apply(parent, queuedValues);
          } catch (ex) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      var n = sources.length,
        queues = arrayInitialize(n, function () { return []; }),
        isDone = arrayInitialize(n, function () { return false; });

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                    d = scheduler.scheduleWithState(state2, function (scheduler1, state3) {
                        if (isAdded) {
                            group.remove(d);
                        } else {
                            isDone = true;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                    d = scheduler[method].call(scheduler, state2, dueTime1, function (scheduler1, state3) {
                        if (isAdded) {
                            group.remove(d);
                        } else {
                            isDone = true;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

                    try {
                        running = predicate.call(thisArg, x, i++, observable);
                    } catch (e) {
                        observer.onError(e);
                        return;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

                try {
                    result = selector.call(thisArg, value, count++, parent);
                } catch (exception) {
                    observer.onError(exception);
                    return;

• Read up
  Read up

Similar blocks of code found in 3 locations. Consider refactoring.

Open

                try {
                    shouldRun = predicate.call(thisArg, value, count++, parent);
                } catch (exception) {
                    observer.onError(exception);
                    return;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            return source.subscribe(function (x) {
                try {
                    onNextFunc(x);
                } catch (e) {
                    observer.onError(e);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                } else {
                    try {
                        onError(exception);
                    } catch (e) {
                        observer.onError(e);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        clearImmediate = typeof (clearImmediate = freeGlobal && moduleExports && freeGlobal.clearImmediate) == 'function' &&
        !reNative.test(clearImmediate) && clearImmediate;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      var setImmediate = typeof (setImmediate = freeGlobal && moduleExports && freeGlobal.setImmediate) == 'function' &&
        !reNative.test(setImmediate) && setImmediate,

• Read up
  Read up