RxJS可观察到：重复使用count然后使用notifier

Question

I have an Observable that emits Either = Success | Failure Either = Success | Failure :

import { Observable } from 'rxjs';

type Success = { type: 'success' };
type Failure = { type: 'failure' };

type Either = Success | Failure;

const either$ = new Observable<Either>(observer => {
    console.log('subscribe');
    observer.next({ type: 'failure' });
    observer.complete();
    return () => {
        console.log('unsubscribe');
    };
});

I want to allow the user to "retry" the observable when the Observable completes and the last value was Failure .

(The retry{,When} operators do not help here because they work with errors on the error channel. For this reason, I believe we should think in terms of repeat instead.)

I want to:

• Repeat the Observable n times until the last value is not Failure .
• Then, allow the user to repeat manually. When a repeat notifier observable ( repeat$ ) emits, repeat the observable again.

For example:

// subscribe
// next { type: 'failure' }
// unsubscribe

// retry 2 times:

// subscribe
// next { type: 'failure' }
// unsubscribe

// subscribe
// next { type: 'failure' }
// unsubscribe

// now, wait for repeat notifications…
// on retry notification:

// subscribe
// next { type: 'failure' }
// unsubscribe

Answer 1

I couldn't come up with something simpler, but the code does what you want.

See https://stackblitz.com/edit/typescript-yqcejk

defer(() => {
   let retries = 0;

   const source = new BehaviorSubject(null);

   return merge(source, repeat$.pipe(filter(() => retries <= MAX_RETRIES)))
       .pipe(
           concatMapTo(either$),
           tap(value => {
               const action = value as Either;
               if (action.type === 'failure') {
                   if (retries < MAX_RETRIES) {
                       retries += 1;
                       source.next(null);
                   }
               } else {
                   retries = 0;
               }
           })
       )
}).subscribe(console.log);

I had to manually count retries.

The code has two sources of events source for automatic retries and repeat$ for user retries. All events are mapped to either$ using concatMapTo . As a side-effect we either next() to retry or do nothing waiting for user to retry.

User retries are suppressed using filter(() => retries >= MAX_RETRIES) until MAX_RETRIES count is reached.