TypeScript Observable.combineLatest方法代碼示例

  waitForTxnDetailDataToLoad(): Observable<any> {

    this.txnDetail$ = Observable.combineLatest(
           this.store.select(fromRoot.getCustomerDetails),
           this.store.select(fromRoot.getLoggedInUser),
           this.store.select(fromRoot.getDetailTransaction),
           this.store.select(fromRoot.getSelectedpropertyName),
           (custDtls, loggedInUser, txnDtl, propertyName) => {
             var businessInfo = {firstName:loggedInUser.firstName,
                                 lastName:loggedInUser.lastName,
                                 email:loggedInUser.email,
                                 phoneNumber: (undefined != loggedInUser.phoneNum)?loggedInUser.phoneNum:'Not Provided',
                                 faxNumber:(undefined != loggedInUser.faxNum)?loggedInUser.faxNum:'Not Provided',
                                 addr: custDtls.contactAddress,
                                 fedTaxId:(undefined != custDtls.fedTaxId)?custDtls.fedTaxId:'Not Provided',
                                 languagePref:custDtls.correspondenceLang
                               }
             return {businessInfo,txnDtl,propertyName}
         });

     return new Observable(observer => {
           this.txnDetail$.subscribe(dtl => {
              if(dtl.txnDtl.isLoadingSuccess){
                observer.next(dtl);
                observer.complete();
              }
          })
     });
  }

 constructor(public store: Store<any[]>) {
   this.filteredTodos = Observable.combineLatest(store.select('todos'), store.select('visibility'), (todos: any, visibilityFilter: any) => todos.filter(visibilityFilter.filter));
   this.todos = store.select('todos');
   this.visibilityFilter = store.select('visibility');
   this.completedCount = this.todos.map((todos: any) => todos.reduce((count, todo) => todo.completed ? count + 1 : count, 0));
   this.activeCount = this.todos.map((todos: any) => todos.length - (todos.reduce((count, todo) => todo.completed ? count + 1 : count, 0)));
 }

  return new Promise<void>(resolve => {
    let timer;

    if (typeof timeout === 'number' && timeout > 0) {
      timer = setTimeout(() => {
        console.warn(chalk.yellow(`Timed out while waiting for NgZone to become stable after ${timeout}ms! This is a serious performance problem!`));
        console.warn(chalk.yellow('This likely means that your application is stuck in an endless loop of change detection or some other pattern of misbehaviour'));
        console.warn(chalk.yellow('In a normal application, a zone becomes stable very quickly'));
        console.warn('Proceeding with render operation even though the zone is not stable: this is a very dangerous thing to do!')
        console.warn('You can adjust the zone-becomes-stable timeout with ApplicationBuilder::stabilizeTimeout(), or zero to disable');
        resolve();
      },
      timeout);
    }

    const combined = Observable.combineLatest(applicationRef.isStable, requests.requestsPending(),
      (appStable, pending) => {
        return appStable && pending === 0;
      });

    const subscription = combined.subscribe(v => {
      if (v === true) {
        if (subscription) {
          subscription.unsubscribe();
        }
        if (timer != null) {
          clearTimeout(timer);
        }
        resolve();
      }
    });
  });

 constructorZone3.run(() => {
   combinedObservable =
       Rx.Observable.combineLatest(observable1, observable2, (x: number, y: number) => {
         expect(Zone.current.name).toEqual(constructorZone3.name);
         return x + y;
       });
 });

    //TODO: create as a computed store service: 
    //  http://onehungrymind.com/handle-multiple-angular-2-models-ngrx-computed-observables/
    constructor(private _store: Store<AppState> /*, private _itemService: TripService*/) {
        this.searchTab = new Tab();
        this.searchTab.id = 'tab-id-search';
        this.searchTab.title = 'Search';
        this.searchTab.template = 'search';
        this.searchTab.active = true;
        this.searchTab.closeable = false;
        this.searchTab.itemId = '';

        this.activeTabId$ = _store.select(x => x.trip.activeTabId);
        this.openItems$ = _store.select(x => x.trip.openList);
        this.tabs$ = this.openItems$
            .combineLatest(this.activeTabId$)
            .map(([trips, activeId]) => {
                this.searchTab.active = activeId === this.searchTab.id || !activeId;
                return [this.searchTab].concat(trips.map(item => {
                    let exists = item.Trip && item.Trip.TripId && item.Trip.TripId.length > 0;
                    let t = new Tab();
                    t.id = item.PlaceholderId;
                    t.title = exists ? item.Trip.DepartDate : 'Add Trip'; //TODO: what is a good title here??
                    t.template = 'item';
                    t.active = activeId === t.id;
                    t.closeable = true;
                    t.item = item;
                    t.itemId = item.Trip.TripId;
                    return t;
                }));
            });
    }

export function todoItemDataFlow(intent: TodoItemIntent, todoProperty$: Observable<Todo>){
    const editing$ = Observable.merge<boolean, boolean>(
        intent.startEdit$.map(() => true),
        intent.stopEdit$.map(() => false),
        intent.cancelEdit$.map(() => false)
    ).startWith(false);

    const viewModel$ = todoProperty$
        .combineLatest(editing$, (todoProperty, editing) => Object.assign({}, todoProperty, { editing }));

    const delete$ = intent.delete$
        .withLatestFrom(todoProperty$, (_, todo: Todo) => todo)
        .map(x => ({ id: x.id }));

    const edit$ = intent.stopEdit$
        .withLatestFrom(todoProperty$, (title: string, todo: Todo) => ({ title, todo }))
        .filter(x => x.title !== x.todo.title)
        .map(x => ({ id: x.todo.id, title: x.title }));

    const toggle$ = intent.toggleTodo$
        .withLatestFrom(todoProperty$, (_, todo: Todo) => todo)
        .map(todo => ({ id: todo.id }));

    return {
        viewModel$,
        delete$,
        edit$,
        toggle$
    };
}

export const compileTickObservable = (items$, stop$, start$) => {

  /**
   * Observable stream that emits the number of ms passed since it's started at interval of minInterval
   */
  const timer$ = Observable.interval(minInterval)
    .map(val => val * minInterval);

  /**
   * This observable combines both the timer stream and the stream injected from the store (which contains the items)
   * Outputs the items whose interval match the time
   */
  const matchedItems$ = Observable.combineLatest(
    items$,
    timer$,
    (items, timer) => ({items: items, timer: timer}) // mapping for combineLatest as last param
  )
    .takeUntil(stop$) // stop the stream when receiving incoming from the stop$ stream (a click)
    .filter(data => {
      return matchItemsIntervalToTimer(data.items, data.timer).length; // filter the timers without any matches
    })
    .distinct((previousData, nextData) => previousData.timer === nextData.timer) // make sure we dont emit twice the same timer
    .map(data => ({items: matchItemsIntervalToTimer(data.items, data.timer), timer: data.timer })); // only return the matches for this time

  // we return a stream that will start when start$ receives incomming
  return start$
    .startWith({}) // start automatically the stream when incomming data at init
    .switchMapTo(matchedItems$); // simply pass the logic above
};

        it("should not cause the command to be executed twice when the condition changes during execution", (done) => {
            class MyInnerClass extends ReactiveObject {
                constructor() {
                    super();
                    this.prop = "";
                }

                public get prop(): string {
                    return this.get("prop");
                }
                public set prop(val: string) {
                    this.set("prop", val);
                }
            }
            class MyClass extends ReactiveObject {
                constructor() {
                    super();
                    this.value = new MyInnerClass();
                }
                public get value(): MyInnerClass {
                    var val = this.get("value");
                    if (!val) {
                        val = new MyInnerClass();
                        this.value = val;
                    }
                    return val;
                }
                public set value(val: MyInnerClass) {
                    this.set("value", val);
                }
            }
            var obj: MyClass = new MyClass();
            var innerCommand = ReactiveCommand.create((a) => {
                return obj.value.prop;
            });
            var isValid = obj.whenAnyValue(vm => vm.value.prop).map(c => {
                return !!c.trim();
            });
            var canExecute = Observable.combineLatest(
                isValid,
                innerCommand.isExecuting.map(ie => !ie),
                (valid, notRunning) => {
                    return valid && notRunning
                }
            )
            var count: number = 0;
            var command: ReactiveCommand<any, any> = ReactiveCommand.createFromObservable((a) => {
                count++;
                obj.value = new MyInnerClass();
                return innerCommand.execute();
            }, canExecute);
            obj.value.prop = "Custom";
            command.execute().subscribe(() => {
                expect(count).to.equal(1);
            }, err => done(err), () => done());
        });

 onSubmit(value: any): void {
   var self : ThreadDetailComponent = this;
   var id : string;
   Observable.combineLatest<string,string>(
                   this._routeParams.switchMap((params: Params) => (id = params['id'])),
                   this.rService.observeServicesLink('threads')
             ).flatMap<Response>(([id,link], index) => this.rService.post('posts', {thread:link+'/'+id, body:value['message']})
             ).flatMap(response=>this.rService.observeService('threads', '/'+id+'/posts')
           ).take(1).subscribe(response=>{self.data['posts']=response.json()._embedded['posts'];self.postForm.reset();}
                             ,error=>console.log(error));
 }

    constructor(private store: Store<fromRoot.State>, private formsService: FormsService, private appConfig: AppConfigService) {

        this.initSubs = Observable.combineLatest(
            store.select(fromRoot.getRelationshipIdForStartStopTxn),
            store.select(fromRoot.getSelectedPropertyBPType)
        ).subscribe((result: any) => {
            this.relationshipId = result[0];
            this.bpType = result[1];
        })

        this.downloadRestUrl = this.appConfig.readEnvironment('downloadRestUrl');
    }