TypeScript BehaviorSubject.getValue方法代码示例

  /**
   * Emit initial audio Adaptation through the given Subject based on:
   *   - the preferred audio tracks
   *   - the last choice for this period, if one
   * @param {Period} period
   *
   * @throws Error - Throws if the period given has not been added
   */
  public setInitialAudioTrack(period : Period) : void {
    const periodItem = getPeriodItem(this._periods, period);
    const audioInfos = periodItem && periodItem.audio;
    if (!audioInfos || !periodItem) {
      throw new Error("TrackManager: Given Period not found.");
    }

    const preferredAudioTracks = this._preferredAudioTracks.getValue();
    const audioAdaptations = period.adaptations.audio || [];
    const chosenAudioAdaptation = this._audioChoiceMemory.get(period);

    if (
      chosenAudioAdaptation === undefined ||
      !arrayIncludes(audioAdaptations, chosenAudioAdaptation)
    ) {
      const normalizedTracks = normalizeAudioTracks(preferredAudioTracks);
      const optimalAdaptation =
        findFirstOptimalAudioAdaptation(audioAdaptations, normalizedTracks);

      this._audioChoiceMemory.set(period, optimalAdaptation);
      audioInfos.adaptation$.next(optimalAdaptation);
    } else {
      audioInfos.adaptation$.next(chosenAudioAdaptation);
    }
  }

it("for: bind to a value yielding an array", async (t) => {
    const template = `<ul><li x-for:item.i="src" x-text="i"></li></ul>`;
    const el = parse(template)[0] as HTMLElement;

    const prop = new BehaviorSubject<number[]>([]);

    t.notThrows(() => ui.domManager.applyDirectives({ src: prop }, el));
    t.is(el.children.length, prop.getValue().length);
    t.deepEqual(toArray(el.children).map((node) => parseInt(node.textContent || "")), range(0, prop.getValue().length));

    const array = [1, 5, 7];
    prop.next(array);
    t.is(el.children.length, prop.getValue().length);
    t.deepEqual(toArray(el.children).map((node) => parseInt(node.textContent || "")), range(0, prop.getValue().length));

});

  subscribeUsers(): Subscription {
    // Fetch all users matching search pattern
    const subscription = MeteorObservable.subscribe('users', this.searchPattern.getValue());
    const autorun = MeteorObservable.autorun();

    return Observable.merge(subscription, autorun).subscribe(() => {
      this.users = this.findUsers();
    });
  }

 public async setFavourite(person: PersonDTO, isFavourite: boolean): Promise<void> {
   const updated = await this.networkService.postJson<PersonDTO>('/person/' + person.name, {isFavourite: isFavourite});
   const updatesList = this.persons.getValue();
   for (let i = 0; i < updatesList.length; i++) {
     if (updatesList[i].id === updated.id) {
       updatesList[i] = updated;
       this.persons.next(updatesList);
       return;
     }
   }
 }

it("value: Should update observable properties on the model when the radio's click event fires", async (t) => {
    const template = `<input type="radio" x-value="someProp" value="my"/>`;
    const element = parse(template)[0] as HTMLInputElement;

    const myobservable = new BehaviorSubject("other");
    ui.domManager.applyDirectives({ someProp: myobservable }, element);

    triggerEvent(element, "click");
    t.is(myobservable.getValue(), "my");

});

it("value: input values type should be consistent", async (t) => {
    const template = `<input type="number" x-value="someProp" />`;
    const number = new BehaviorSubject(0);
    const el = parse(template)[0] as HTMLInputElement;
    const viewmodel = { someProp: number };
    ui.domManager.applyDirectives(viewmodel, el);

    el.value = "3";
    triggerEvent(el, "change");
    t.is(4, 1 + number.getValue());

});

  private _updateTextTrackChoices() {
    const preferredTextTracks = this._preferredTextTracks.getValue();
    const normalizedTracks = normalizeTextTracks(preferredTextTracks);

    const recursiveUpdateTextTrack = (index : number) : void => {
      if (index >= this._periods.length()) {
        // we did all text Buffers, exit
        return;
      }

      const periodItem = this._periods.get(index);
      if (periodItem.text == null) {
        // No text Buffer for this period, check next one
        recursiveUpdateTextTrack(index + 1);
        return;
      }

      const {
        period,
        text: textItem,
      } = periodItem;
      const textAdaptations = period.adaptations.text || [];
      const chosenTextAdaptation = this._textChoiceMemory.get(period);

      if (
        chosenTextAdaptation === null ||
        (
          chosenTextAdaptation !== undefined &&
          arrayIncludes(textAdaptations, chosenTextAdaptation)
        )
      ) {
        // Already best text for this Buffer, check next one
        recursiveUpdateTextTrack(index + 1);
        return;
      }

      const optimalAdaptation =
        findFirstOptimalTextAdaptation(textAdaptations, normalizedTracks);

      this._textChoiceMemory.set(period, optimalAdaptation);
      textItem.adaptation$.next(optimalAdaptation);

      // previous "next" call could have changed everything, start over
      recursiveUpdateTextTrack(0);
    };

    recursiveUpdateTextTrack(0);
  }

    .switchMap(event => {
      startButton.value = 'RESTART';
      pauseButton.disabled = false;
      const game = gameState$$.getValue();
      pauseButton.disabled = false;

      if (game.firstRun) {
        game.firstRun = false;
      } else {
        game.actors = actorsInit();
        game.paused = true;
        game.gameOver = false;
      }

      const gameOver$ = gameState$$.pluck('gameOver').distinct().filter(gameOver => gameOver===true);
      const pauseClick$ = Observable.fromEvent(pauseButton, 'click')
      return Observable.merge(gameOver$, pauseClick$)
        .startWith('whatever')
        .switchMap(event => {
          switch(true) {
            case event===true:
              pauseButton.value = 'GAME OVER';
              pauseButton.disabled = true;
              return Observable.of(game)
            default:
              game.paused = !game.paused;
              switch (game.paused) {
                case true:
                  pauseButton.value = 'CONTINUE';
                  return Observable.of(game);
                case false:
                  pauseButton.value = 'PAUSE';
                  return onContinue$Fac(game);
              }
          }
        })
    })

 getDevices(): Device[] {
     return this._loadedDevices.getValue();
 }