rxjs/operators#delay TypeScript Examples

function delayedRetry(delayMs: number, maxRetry = DEFAULT_MAX_RETRIES) {
  let retries = maxRetry;

  return (src: Observable<any>) =>
    src.pipe(
      retryWhen((errors: Observable<any>) => errors.pipe(
        delay(delayMs),
        mergeMap(error => retries-- > 0 ? of(error) : throwError(error))
      ))
    );
}

monthlySummaryEmailBannerEpic: EpicSignature = (action$, state$) => {
  return action$.pipe(
    filter(
      isActionOf([Actions.setAddressSuccess, Actions.initializeAppSuccess]),
    ),
    filter(() => {
      // Make development easier, whatever...
      if (ENV.ENABLE_MOCK_APIS) {
        return true;
      }

      const dismissed = state$.value.app.app.dismissedBannerKeys;
      return !dismissed.has("monthly_summary_newsletter");
    }),
    take(1),
    delay(2500),
    map(() =>
      Actions.toggleNotificationsBanner({
        key: "monthly_summary_newsletter",
        visible: true,
      }),
    ),
  );
}

portResponseSubscription: Subscription = merge(
    this.connectHandler$,
    this.signXDRHandler$
  )
    .pipe(catchError(error => {
      console.error(error);
      return of({
        error: true,
        errorMessage: 'Connection failed',
      });
    }))
    .pipe(delay(800))
    .pipe(withLatestFrom(this.connectedPort$))
    .pipe(takeUntil(this.componentDestroyed$))
    .subscribe(([response, port]) => {
      port.postMessage(response);
      port.disconnect();
      window.close();
    });

/**
   * Sends request to add trade.
   * @return InstantTradesResponseApi Instant trade object.
   */
  public createTrade(
    hash: string,
    provider: INSTANT_TRADE_PROVIDER,
    trade: InstantTrade,
    fee?: number,
    promoCode?: string
  ): Observable<InstantTradesResponseApi> {
    const hashObject = InstantTradesApiService.getHashObject(trade.blockchain, hash);
    const tradeInfo: InstantTradesPostApi = {
      network: TO_BACKEND_BLOCKCHAINS[trade.blockchain],
      provider,
      from_token: trade.from.token.address,
      to_token: trade.to.token.address,
      from_amount: Web3Pure.toWei(trade.from.amount, trade.from.token.decimals),
      to_amount: Web3Pure.toWei(trade.to.amount, trade.to.token.decimals),
      user: this.authService.userAddress,
      fee,
      promocode: promoCode,
      ...hashObject
    };

    const url = instantTradesApiRoutes.createData(this.walletConnectorService.provider.walletType);
    return this.httpService.post<InstantTradesResponseApi>(url, tradeInfo).pipe(delay(1000));
  }

validateDate(value: any): Observable<any | null> {
    let message = null;
    for (const item of value) {
      if (item.id === '2') {
        message = {
          'zh-cn': `当前日期队列已满`,
          'en-us': 'The task queue on the current execution day (Tuesday) is full.',
        };
      }
    }
    // Returned by the simulated backend interface
    return of(message).pipe(delay(300));
  }

private presentPopover(popover: HTMLIonPopoverElement, dismissTime?: number): Observable<any> {
    const manualDismiss$ = defer(() => popover.present())
      .pipe(
        switchMap(() => from(popover.onDidDismiss())),
      );
    const autoDismiss$ = defer(() => popover.present())
      .pipe(
        delay(dismissTime),
        switchMap(() => popover.dismiss()),
      );
    return (dismissTime) ? autoDismiss$ : manualDismiss$;
  }

loadAssets$ = createEffect(() => this.actions$.pipe(
    ofType(loadAssets),
    withLatestFrom(
      this.store$.pipe(select(selectLoadedAssets))
    ),
    switchMap(([action, loadedAssets]) => {
      this.store$.dispatch(setLoadingMessage({message: 'Loading website assets.'}));
      if ( loadedAssets ) {
        this.store$.dispatch(setLoadingMessage({message: '<b>Loading</b> done.'}));
        return [loadAssetsSuccess({loadedAssets})];
      } else {
        return this.assetsService.getAll().pipe(
          switchMap(assets => {
            this.store$.dispatch(setLoadingMessage({message: '<b>Loading</b> done.'}));
            return of(assets);
          }),
          delay(2000),
          switchMap(assets => {
            return of(loadAssetsSuccess({loadedAssets: assets}));
          })
        );
      }
    }))
  );

@Saga()
  dragonKilled = (events$: Observable<any>): Observable<ICommand> => {
    return events$.pipe(
      //@ts-ignore
      filter((ev) => ev instanceof HeroKilledDragonEvent),
      //@ts-ignore
      delay(400),
      //@ts-ignore
      map((event: HeroKilledDragonEvent) => {
        this.context.setCachedValue(
          CONTEXT_CORRELATION_ID,
          event?.metadata?.correlation_id || v4(),
        );
        console.log(
          clc.redBright('Inside [HeroesGameSagas] Saga after a little sleep'),
        );
        console.log(event);
        return new DropAncientItemCommand(event.data.heroId, itemId);
      }),
    );
  };

/**
	 * On Right Click: open quick actions menu
	 */
	@HostListener('contextmenu', ['$event'])
	onRightClick(ev: MouseEvent): void {
		ev.preventDefault(); // Stop the default context menu from opening

		if (!!this.emote) this.openContext.next(this.emote);
		this.contextMenuTrigger?.openMenu();

		this.contextMenuTrigger?.menuClosed.pipe(
			take(1),
			delay(50),
			tap(() => this.updateBorderColor())
		).subscribe();
	}

public ngAfterViewInit(): void {
    of(true)
      .pipe(
        first(),
        delay(1000),
        switchMap(() => from(this.loadAddon())),
        catchError((e) => {
          console.error(e);
          return of(undefined);
        })
      )
      .subscribe();
  }

ngAfterViewInit(): void {
    this.theme.getJsTheme()
      .pipe(
        takeWhile(() => this.alive),
        delay(1),
      )
      .subscribe(config => {
        const eTheme: any = config.variables.orders;

        this.setOptions(eTheme);
        this.updateOrdersChartOptions(this.ordersChartData);
      });
  }

private checkEmail(control: AbstractControl): Observable<ValidationErrors | null> {
    if (control.value && (<string>control.value).trim().length > 0) {
      return of(control.value).pipe(
        delay(500),
        switchMap((email) => this.contactService.doesEmailExist(email).pipe(
          map(emailExists => emailExists ? { emailExists: true } : null)
        ))
      );
    } else {
      return of(null);
    }
  }

/**
   * called whenever the user types something
   */
  filter(value: any, schema: Schema, current: string, choices: Observable<Choice[]>): Observable<Choice[]> {
    // filter and convert to Choice[]
    const filtered = this.countries.filter(c => current ? ('' + c).toLowerCase().includes(('' + current).toLowerCase()) : true);

    // limit to 5 preview results
    while (filtered.length > 5) {
      filtered.pop();
    }

    const mapped: Choice[] = filtered.map(c => ({ name: c, value: c }));

    // return with a delay of 0.5 second to simulate an HTTP call
    console.log('requesting data for ' + current);
    return of(mapped).pipe(delay(500));
  }

callbackFunc(newValue) {
    console.log(newValue);
    const newOptions = this.options.filter((option) => {
      console.log(option);
      return option.toUpperCase().includes(newValue.toUpperCase());
    });
    return of(newOptions).pipe(
      switchMap((options) => of(options).pipe(delay(1000)))
    );
  }

getConnectionStatus() {
    return this.isConnected$.pipe(
      startWith(true),
      pairwise(),
      switchMap(([previousConnectionStatus, currentConnectionStatus]) => {
        if (previousConnectionStatus === false && currentConnectionStatus === true) {
          return concat(
            of(ConnectionMessageStatus.onlineMessageShown),
            of(ConnectionMessageStatus.onlineMessageHidden).pipe(delay(3000))
          );
        } else if (previousConnectionStatus === true && currentConnectionStatus === true) {
          return of(ConnectionMessageStatus.onlineMessageHidden);
        } else {
          return of(ConnectionMessageStatus.disconnected);
        }
      })
    );
  }

attachSearch = (
	rawSubscription: APISubscription<RawSearchMessageReceived, RawSearchMessageSent>,
	searchID: NumericID,
): Promise<RawSearchAttachedMessageReceived> => {
	// Generate a unique ID for the search initiating request
	const requestID = uuidv4();

	// Create a promise to receive search initation results
	const results$ = SEARCH_ATTACH_RESULTS.pipe(
		// We only want results relevant to this request
		filter(({ requestID: msgRequestID }) => msgRequestID === requestID),

		// There's only one response to the request, so we're done after the first
		first(),

		// If msg.data.Error is nil, the backend is happy  - continue
		// If msg.data.Error is NON-nil, there's a problem - reject
		concatMap(({ msg }) => (isNil(msg.data.Error) ? of(msg) : throwError(msg))),

		// It takes the backend a fraction of a second to be ready for requests after we set up the search
		delay(200),
	);

	// set up the promise so we can subscribe then next the queue
	const resultsP = firstValueFrom(results$);

	// Now that we're ready to receive results (with resultsP), we can push on the queue to kick off the search initiation process
	ATTACH_QUEUE.next({ requestID, rawSubscription, searchID });

	return resultsP;
}

private showStep(step: T): void {
        const anchor = this.anchors[step && step.anchorId];

        if (!anchor) {
            if (step.isAsync) {
                this.anchorRegister$
                    .pipe(
                        filter(anchorId => anchorId === step.anchorId),
                        first(),
                        delay(0)
                    )
                    .subscribe(
                        () => this.showStep(step)
                    );
                return;
            }
            if (step.isOptional) {
                this.direction === Direction.Forwards ? this.next() : this.prev();
                return;
            }

            console.warn(
                'Can\'t attach to unregistered anchor with id ' + step.anchorId
            );
            this.end();
            return;
        }
        anchor.showTourStep(step);
        this.stepShow$.next(step);
    }

checkLogin(username, password): Observable<boolean | void> {
    // logic to check password

    return this.userService.findUser(username, password).pipe(
      map(userFromBackend => {
        if (userFromBackend && userFromBackend.token) {

          // Get user data from Browser!!
          localStorage.setItem('currentUserKey', JSON.stringify(userFromBackend.token));

          console.log('User Found !!--- ');

          return true;
        }
        return false;

      }),
      delay(500)); // Delay just for fun !!!
  }

public constructor(
        protected pipe: DecimalPipe,
        protected appCommon: AppCommonService,
    ) {

        this.listenToPlayerChanges();

        this._search$
            .pipe(
                tap(() => this._loading$.next(true)),
                debounceTime(120),
                switchMap(() => this._search()),
                delay(120),
                tap(() => this._loading$.next(false)),
            )
            .subscribe((result) => {
                this._audits$.next(result.audits);
                this._total$.next(result.total);
            });

        this._search$.next();
    }

// notify the dynControls about the incoming data
  patchValue(value: any): void {
    this.whenReady().pipe(
      tap(() => {
        this.node.markAsPending();
        this.logger.formCycle('PrePatch');
        this.callHook('PrePatch', value);
      }),
      delay(20), // waits any PrePatch loading change
      switchMap(() => {
        this.node.markAsLoaded();
        return this.whenReady();
      }),
      tap(() => {
        this.logger.formCycle('PostPatch', this.form.value);
        this.form.patchValue(value);
        this.callHook('PostPatch', value);
      }),
    ).subscribe();
  }

ngAfterViewInit(): void {
    this.theme.getJsTheme()
      .pipe(
        takeWhile(() => this.alive),
        delay(1),
      )
      .subscribe(config => {
        const eTheme: any = config.variables.orders;

        this.setOptions(eTheme);
        this.updateOrdersChartOptions(this.ordersChartData);
      });
  }

onTradeLogUpdate$ = createEffect(() =>
    iif(
      () => this.useMockData,
      of(
        addTradeLogs({
          tradeLogs: mockTradeLogs,
        })
      ).pipe(
        delay(500),
        tap(() => console.warn('Using MOCKED data'))
      ),
      this.store.select(selectLatestEntryTime).pipe(
        map(
          (latest) =>
            latest && new Timestamp(latest.seconds, latest.nanoseconds).toDate()
        ),
        take(1),
        switchMap((latest) =>
          merge(
            ...environment.tradeLogs.map((tl) =>
              this.firestore
                .collection<TradeLogEntry>(tl, (ref) =>
                  (latest ? ref.where('close', '>', latest) : ref).orderBy(
                    'close'
                  )
                )
                .valueChanges({ idField: 'id' })
                .pipe(
                  map((entries) => entries.map((e) => ({ ...e, alias: tl })))
                )
            )
          ).pipe(
            tap(() => console.warn('Using LIVE data')),
            map((tradeLogs) => addTradeLogs({ tradeLogs }))
          )
        )
      )
    )
  );

startHeartbeat(): void {
    this.stopHeartbeat();
    this.networkError = false;

    const heartbeat$ = timer(1_000, 30_000)
      .pipe(
        tap(() => this.connect().next('ping')),
        concatMap(_ => {
          return race(
            of('timeout').pipe(delay(3_000)),
            this.connect().pipe(filter(m => m === 'pong'), catchError(() => of('error')))
          );
        })
      );

    this.heartbeatSubscription = heartbeat$.subscribe(msg => {
      if (msg === 'pong') {
        this.networkError = false;
      } else {
        this.networkError = true;
        this.webSocketSubject?.complete();
        this.webSocketSubject = null;
      }
    });
  }

onApplySuggestion(suggestion: LabelSuggestion): void {
    // Do nothing if the label is unchanged
    if (suggestion.value === this.initialLabel && !suggestion.new) {
      this.ref.close();
      return;
    }

    let prep$: Observable<void> = of(null)

    // If the label is not empty then check it is not one of the existing labels
    if (suggestion.value && suggestion.new) {
      prep$ = this.api.createLabel(suggestion.value).pipe(
        // Deluge has issues when a torrent label is set immediately after setting it
        delay(200)
      )
    }

    prep$.pipe(
      switchMap(_ => this.api.setTorrentLabel(this.id, {Label: suggestion.value}))
    ).subscribe(
      _ => this.ref.close(suggestion.value)
    )
  }

export function beforeEach<T, V>(valueBefore: V) {
  return (source$: Observable<T>) =>
    defer(() => {
      const subject$ = new ReplaySubject<V | T>(1);
      source$
        .pipe(
          // Force the source values emitted asynchronizingly.
          delay(0)
        )
        .subscribe({
          next: v => {
            subject$.next(valueBefore);
            subject$.next(v);
          },
          error: (err: unknown) => subject$.error(err),
          complete: () => subject$.complete(),
        });
      return subject$.pipe(
        // Make sure the values emitted asynchronizingly.
        concatMap(v => of(v).pipe(delay(0)))
      );
    });
}

describe('marbleTest()', () => {
  it('has fancy typing', () => {
    staticTest(() => {
      expectTypeOf(marbleTest(noop)).toEqualTypeOf<VoidFunction>();
      expectTypeOf(marbleTest(async () => 1)).toEqualTypeOf<
        () => Promise<number>
      >();
    });
  });

  // https://github.com/ReactiveX/rxjs/blob/master/docs_app/content/guide/testing/marble-testing.md
  it(
    'works for the first example in the docs',
    marbleTest(
      ({ cold, expectObservable, expectSubscriptions, testScheduler }) => {
        const e1 = cold(' -a--b--c---|');
        const subs = '    ^----------!';
        const expected = '-a-----c---|';

        expectObservable(e1.pipe(throttleTime(3, testScheduler))).toBe(
          expected,
        );
        expectSubscriptions(e1.subscriptions).toBe(subs);
      },
    ),
  );

  it(
    'works for two tests in a row',
    marbleTest(({ cold, expectObservable }) => {
      const input = ' -a-b-c|';
      const expected = '-- 9ms a 9ms b 9ms (c|)';

      const result = cold(input).pipe(concatMap((d) => of(d).pipe(delay(10))));

      expectObservable(result).toBe(expected);
    }),
  );
});

captureProfile(options: CaptureProfileOptions):
      Observable<CaptureProfileResponse> {
    if (this.isLocalDevelopment) {
      return of({result: 'Done'});
    }
    const params =
        new HttpParams()
            .set('service_addr', options.serviceAddr)
            .set('is_tpu_name', options.isTpuName.toString())
            .set('duration', options.duration.toString())
            .set('num_retry', options.numRetry.toString())
            .set('worker_list', options.workerList)
            .set('host_tracer_level', options.hostTracerLevel.toString())
            .set('device_tracer_level', options.deviceTracerLevel.toString())
            .set('python_tracer_level', options.pythonTracerLevel.toString())
            .set('delay', options.delay.toString());
    return this.httpClient.get(this.pathPrefix + CAPTURE_PROFILE_API, {params});
  }

constructor(private cardService: CardService, private progress: ProgressService) {
        this.progress.isLoading(true);
        this.allCards$ = this.cards.pipe(
            delay(1000),
            tap(() => {
                this.progress.isLoading(false);
            })
        );
    }

public signin(username, password) {
    return of({token: DEMO_TOKEN, user: DEMO_USER})
      .pipe(
        delay(1000),
        map((res: any) => {
          this.setUserAndToken(res.token, res.user, !!res);
          this.signingIn = false;
          return res;
        }),
        catchError((error) => {
          return throwError(error);
        })
      );

    // FOLLOWING CODE SENDS SIGNIN REQUEST TO SERVER

    // this.signingIn = true;
    // return this.http.post(`${environment.apiURL}/auth/local`, { username, password })
    //   .pipe(
    //     map((res: any) => {
    //       this.setUserAndToken(res.token, res.user, !!res);
    //       this.signingIn = false;
    //       return res;
    //     }),
    //     catchError((error) => {
    //       return throwError(error);
    //     })
    //   );
  }