text: import { OuterSubscriber } from '../OuterSubscriber';
  import { subscribeToResult } from '../util/subscribeToResult';
  /* tslint:enable:max-line-length */
  /**
   * Combines the source Observable with other Observables to create an Observable
   * whose values are calculated from the latest values of each, only when the
   * source emits.
   *
   * <span class="informal">Whenever the source Observable emits a value, it
   * computes a formula using that value plus the latest values from other input
   * Observables, then emits the output of that formula.</span>
   *
   * <img src="./img/withLatestFrom.png" width="100%">
   *
   * `withLatestFrom` combines each value from the source Observable (the
   * instance) with the latest values from the other input Observables only when
   * the source emits a value, optionally using a `project` function to determine
   * the value to be emitted on the output Observable. All input Observables must
   * emit at least one value before the output Observable will emit a value.
   *
   * @example <caption>On every click event, emit an array with the latest timer event plus the click event</caption>
   * var clicks = Rx.Observable.fromEvent(document, 'click');
   * var timer = Rx.Observable.interval(1000);
   * var result = clicks.withLatestFrom(timer);
   * result.subscribe(x => console.log(x));
   *
   * @see {@link combineLatest}
   *
   * @param {ObservableInput} other An input Observable to combine with the source
   * Observable. More than one input Observables may be given as argument.
   * @param {Function} [project] Projection function for combining values
   * together. Receives all values in order of the Observables passed, where the
   * first parameter is a value from the source Observable. (e.g.
   * `a.withLatestFrom(b, c, (a1, b1, c1) => a1 + b1 + c1)`). If this is not
   * passed, arrays will be emitted on the output Observable.
   * @return {Observable} An Observable of projected values from the most recent
   * values from each input Observable, or an array of the most recent values from
   * each input Observable.
   * @method withLatestFrom
   * @owner Observable
   */
  export function withLatestFrom() {
      var args = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          args[_i - 0] = arguments[_i];
      }
      return function (source) {
          var project;
          if (typeof args[args.length - 1] === 'function') {
              project = args.pop();
          }
          var observables = args;
          return source.lift(new WithLatestFromOperator(observables, project));
      };
  }
  var WithLatestFromOperator = (function () {
      function WithLatestFromOperator(observables, project) {
          this.observables = observables;
          this.project = project;
      }
      WithLatestFromOperator.prototype.call = function (subscriber, source) {
          return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));
      };
      return WithLatestFromOperator;
  }());
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  var WithLatestFromSubscriber = (function (_super) {
      __extends(WithLatestFromSubscriber, _super);
      function WithLatestFromSubscriber(destination, observables, project) {
          _super.call(this, destination);
          this.observables = observables;
          this.project = project;
          this.toRespond = [];
          var len = observables.length;
          this.values = new Array(len);
          for (var i = 0; i < len; i++) {
              this.toRespond.push(i);
          }
          for (var i = 0; i < len; i++) {
              var observable = observables[i];
              this.add(subscribeToResult(this, observable, observable, i));
          }
      }
      WithLatestFromSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
          this.values[outerIndex] = innerValue;
          var toRespond = this.toRespond;
          if (toRespond.length > 0) {
              var found = toRespond.indexOf(outerIndex);
              if (found !== -1) {
                  toRespond.splice(found, 1);
              }
          }
      };
      WithLatestFromSubscriber.prototype.notifyComplete = function () {
          // noop
      };
      WithLatestFromSubscriber.prototype._next = function (value) {
          if (this.toRespond.length === 0) {
              var args = [value].concat(this.values);
              if (this.project) {
                  this._tryProject(args);
              }
              else {
                  this.destination.next(args);
              }
          }
      };
      WithLatestFromSubscriber.prototype._tryProject = function (args) {
          var result;
          try {
              result = this.project.apply(this, args);
          }
          catch (err) {
              this.destination.error(err);
              return;
          }
          this.destination.next(result);
      };
      return WithLatestFromSubscriber;
  }(OuterSubscriber));
  //# sourceMappingURL=withLatestFrom.js.map