perf(forkJoin): improve forkJoin perf slightly by removing unnecessar…

…y context tracking

src/observable/ForkJoinObservable.ts

@@ -56,82 +56,63 @@ export class ForkJoinObservable<T> extends Observable<T> {
  }
 }
 
-interface ForkJoinContext {
- completed: number;
- total: number;
- values: Array<any>;
- haveValues: Array<boolean>;
- selector: Function;
-}
-
 class ForkJoinSubscriber<T> extends OuterSubscriber<T, T> {
- private context: ForkJoinContext = null;
+ private completed = 0;
+ private total: number;
+ private values: any[];
+ private haveValues = 0;
 
  constructor(destination: Subscriber<T>,
  private sources: Array<SubscribableOrPromise<any>>,
- resultSelector?: (...values: Array<any>) => T) {
+ private resultSelector?: (...values: Array<any>) => T) {
  super(destination);
 
  const len = sources.length;
- this.context = { completed: 0,
- total: len,
- values: new Array(len),
- haveValues: new Array(len),
- selector: resultSelector };
+ this.total = len;
+ this.values = new Array(len);
+
+ for (let i = 0; i < len; i++) {
+ const source = sources[i];
+ const innerSubscription = subscribeToResult(this, source, null, i);
 
- this.tryForkJoin();
+ if (innerSubscription) {
+ (<any> innerSubscription).outerIndex = i;
+ this.add(innerSubscription);
+ }
+ }
  }
 
  notifyNext(outerValue: any, innerValue: T,
  outerIndex: number, innerIndex: number,
  innerSub: InnerSubscriber<T, T>): void {
- const context = this.context;
-
- context.values[outerIndex] = innerValue;
- context.haveValues[outerIndex] = true;
+ this.values[outerIndex] = innerValue;
+ if (!(<any>innerSub)._hasValue) {
+ (<any>innerSub)._hasValue = true;
+ this.haveValues++;
+ }
  }
 
  notifyComplete(innerSub: InnerSubscriber<T, T>): void {
- const outerIndex = (<any>innerSub).outerIndex;
- this.tryComplete(outerIndex);
- }
-
- private tryComplete(index: number): void {
  const destination = this.destination;
- const context = this.context;
+ const { haveValues, resultSelector, values } = this;
+ const len = values.length;
 
- context.completed++;
-
- if (!context.haveValues[index]) {
+ if (!(<any>innerSub)._hasValue) {
  destination.complete();
+ return;
  }
 
- const values = context.values;
- if (context.completed !== values.length) {
+ this.completed++;
+
+ if (this.completed !== len) {
  return;
  }
 
- if (context.haveValues.every(x => x === true)) {
- const value = context.selector ? context.selector.apply(this, values) :
- values;
+ if (haveValues === len) {
+ const value = resultSelector ? resultSelector.apply(this, values) : values;
  destination.next(value);
  }
 
  destination.complete();
  }
-
- private tryForkJoin(): void {
- const sources = this.sources;
- const len = sources.length;
-
- for (let i = 0; i < len; i++) {
- const source = sources[i];
- const innerSubscription = subscribeToResult(this, source, null, i);
-
- if (innerSubscription) {
- (<any> innerSubscription).outerIndex = i;
- this.add(innerSubscription);
- }
- }
- }
 }