Как мне правильно расширить rxjs/Observable с помощью моего первого пользовательского оператора

Я пытаюсь использовать шаблон повтора в вызовах службы (на самом деле: @Effects в ngrx/store) с увеличенными интервалами задержки. Поскольку мне удалось придумать рабочий код для одного вызова (даже если он выглядит неоптимизированным, я не хочу сосредотачиваться на этом в своем вопросе), теперь я хотел бы извлечь его в пользовательский оператор Observable и использовать его повторно. во всех моих служебных вызовах.

Я ничего не знаю о том, как разработать API/использование для нового оператора и как сделать его распознаваемым TypeScript.

Приведенный ниже код точно не работает, потому что, вероятно, накапливает множество проблем.

Итак, теперь у меня есть вызов/эффект следующим образом:

  @Effect()
  loadData$: Observable<Action> = this.actions$
    .ofType(ActionTypes.LOAD_DATA)
    .pluck('payload')
    .switchMap(params => {
      return this.myService.getData(params)
        .map(res => new LoadDataCompleteAction(res))

        // ...and this part would have to be extracted: 
        .retryWhen(attempts => Observable
          .zip(attempts, Observable.range(1, 5))
          .flatMap((n, i) => {
            if (i < 4) {
              return Observable.timer(1000 * i);
            } else {
              throw(n);
            }
          })
        )
    })
    .catch(err => Observable.of(new LoadDataFailed()));

и то, что мне нужно, - это возможность повторно использовать часть повтора в других эффектах и ​​иметь шаблон, аналогичный приведенному ниже:

  @Effect()
  loadData$: Observable<Action> = this.actions$
    .ofType(ActionTypes.LOAD_DATA)
    .pluck('payload')
    .switchMap(params => {
      return this.myService.getData(params)
        .map(res => new LoadDataCompleteAction(res))
        .retryWhen(attempts => Observable.retryOrThrow(attempts, maxAttempts)

         // or maybe - that's my design question
         .retryOrThrow(attempts, maxAttempts)
    })
    .catch(err => Observable.of(new LoadDataFailed()));

Для простоты можно предположить, что шаблон обратного вызова задержки (i * 1000) будет постоянным для всего приложения.

Приведенный ниже код - моя попытка, но она явно не работает.

declare module 'rxjs/Observable' {
  interface Observable<T> {
    retryOrThrow<T>(attempts: any, max: number): Observable<T>;
  }     
}

Observable.prototype.retryOrThrow = function(attempt, max) {
  console.log('retryOrThrow called');

  return Observable.create(subscriber => {
    const source = this;
    const subscription = source.subscribe(() => {
        // important: catch errors from user-provided callbacks
        try {
          subscriber
            .zip(attempt, Observable.range(1, max + 1))
            .flatMap((n, i) => {
              console.log(n, i);
              if (i < max) {
                return Observable.timer(1000 * i);
              } else {
                throw(n);
              }
            });
        } catch (err) {
          subscriber.error(err);
        }
      },
      // be sure to handle errors and completions as appropriate and send them along
      err => subscriber.error(err),
      () => subscriber.complete());

    // to return now
    return subscription;
  });
};

1. Я не уверен, как спроектировать API для нового оператора, какой синтаксис здесь подойдет лучше всего.
2. Я не знаю, как правильно объявить новый оператор и пространство имен или модуль Observable, чтобы TypeScript распознавал новые вещи.

Обновленный сервисный вызов:

  getMocky(){
    const u = Math.random();

    const okUrl = 'http://www.mocky.io/v2/58ffadf71100009b17f60044';
    const erUrl = 'http://www.mocky.io/v2/58ffae7f110000ba17f60046';
    return u > 0.6 ? this.http.get(okUrl) : this.http.get(erUrl);
  }