@one-paragon/angular-utilities 1.2.12 → 1.2.13

package/src/http-request-state/HttpRequestStateStore.ts

@@ -1,173 +0,0 @@
-import { Observable, of, Subscription } from 'rxjs';
-import { ComponentStore } from '@ngrx/component-store';
-import { HttpRequestFactory, HttpRequestStrategy, HttpRequestStatus, HttpRequestState, RequestStateOptions, HttpRequestStateCancelled } from './types';
-import { createFailure, createSuccess, inProgress, isErrorState, isSuccessOrErrorState, isSuccessState, notStarted } from './helpers';
-import { concatMap, filter, map, mergeMap, startWith, switchMap, takeUntil, tap } from 'rxjs/operators';
-import { HttpErrorResponse } from '@angular/common/http';
-import { mapError } from '../rxjs/mapError';
-import { defaultShareReplay } from '../rxjs/defaultShareReplay';
-import { computed, Directive, Injector, isSignal, Signal } from '@angular/core';
-import { toObservable } from '@angular/core/rxjs-interop';
-import { notNull } from '../rxjs';
-
-export interface RequestResponse<TParam extends any[], T> {
-  requestParams: [...TParam];
-  response: HttpRequestState<T>;
-}
-
-@Directive()
-export class HttpRequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> extends ComponentStore<RequestResponse<TParam, T>> {
-    private options?: RequestStateOptions;
-    private project?: (v: V) => R;
-    private req: HttpRequestFactory<TParam, V>;
-    private injector?: Injector;
-    constructor(req: HttpRequestFactory<TParam, V> ,options?: RequestStateOptions<TParam>, project?: (v: V) => R) {
-      super({ requestParams: null as any, response: notStarted });
-      this.project = project;
-      this.options = options;
-      this.injector = options?.injector;
-      this.req = req;
-      this.request = (this.options?.strategy === HttpRequestStrategy.singleUse) ? this.singleUseRequest :  this.flattenedRequest;
-
-      if(options?.autoRequestWith){
-        this.request(...options.autoRequestWith);
-      }
-    }
-
-    reset() {
-      this.setState({ requestParams:null as any, response: notStarted });
-    }
-
-    private flatteningStrategy = () => {
-      if(this.options?.strategy === HttpRequestStrategy.concurrent)
-        return mergeMap( (params: [...TParam]) => this.createRequest(...params));
-      if(this.options?.strategy === HttpRequestStrategy.sequential)
-        return concatMap( (params: [...TParam]) => this.createRequest(...params));
-      return switchMap( (params: [...TParam]) => ((params[0] as any) instanceof CancellationToken) ?
-        of({ requestParams: params[0], response: { status: HttpRequestStatus.cancelled } as HttpRequestStateCancelled } ) : this.createRequest(...params) );
-    }
-
-    private requestEffect: (value: [...TParam] ) => Subscription = this.effect((obs: Observable<[...TParam]>) => {
-      return (obs).pipe(
-        this.flatteningStrategy(),
-        tap<RequestResponse<TParam, T>>(state => this.setState(state)),
-      );
-    });
-
-    private flattenedRequest = (...value: [...TParam]) => {
-      return this.requestEffect(value) as Subscription;
-    }
-    private singleUseRequest = (...value: [...TParam]) => {
-      if (this.get().response.status !== HttpRequestStatus.notStarted) {
-        throw new Error("state can not be reused. either reset the state by calling reset() or use a state requester that allows concurrent requests.");
-      }
-      return this.requestEffect(value) as Subscription;
-    }
-
-    selectHttpState$ = this.state$.pipe(map(a => a.response));
-
-    selectStatus$ = this.selectHttpState$.pipe(map(a => a.status));
-
-    selectError$ = this.state$.pipe(
-      map(r => r.response),
-      filter(isErrorState),
-      map( state => state.error)
-    );
-
-    selectResponse$: Observable<T> = this.state$.pipe(
-      map(r => r.response),
-      filter(isSuccessState),
-      map( state => state.body)
-    );
-    selectSuccessOrError$ = this.state$.pipe(
-      map(r => r.response),
-      filter(isSuccessOrErrorState),
-      map( () => null)
-    );
-
-    errorHandled = false;
-    onError( cb: (error: HttpErrorResponse) => void) {
-      this.errorHandled = true;
-      this.on(this.selectError$, cb);
-      return this;
-    }
-
-    onSuccess( cb: (body?: T) => void) {
-      this.on(this.selectResponse$, cb);
-      return this;
-    }
-
-    onSuccessOrError(cb: () => void){
-      this.on(this.selectSuccessOrError$, cb);
-      return this;
-    }
-
-    onSuccessWithRequest(func: (state: {
-      requestParams: [...TParam];
-      body: T;
-    }) => void) {
-      this.onUpdate(({ requestParams, response }) => {
-        if(isSuccessState(response)){
-          func({requestParams,body: response.body});
-        }
-      });
-      return this;
-    }
-
-    onErrorWithRequest(func: (state: {
-      error: HttpErrorResponse;
-      requestParams: [...TParam];
-    }) => void) {
-      this.onUpdate( ({ requestParams, response }) => {
-        if(isErrorState(response)){
-          func({ requestParams, error: response.error });
-        }
-      });
-      return this;
-    }
-
-    private createRequest(...params: [...TParam]): Observable<RequestResponse<TParam, T>> {
-      return this.req(...params).pipe(
-        map(re => createSuccess((this.project ? this.project(re) : re) as T)),
-        mapError(createFailure),
-        startWith(inProgress),
-        map( state => ({ requestParams: params, response: state })),
-        defaultShareReplay()
-      );
-    }
-
-    onUpdate(func: (state: {
-      requestParams: [...TParam];
-      response: HttpRequestState<T>;
-    }) => void) {
-      this.on(this.state$, func);
-    }
-
-    on = <V>(srcObservable: Observable<V>, func: (obj: V) => void): Subscription => {
-      return this.effect((src: Observable<V>) => {
-        return src.pipe(tap(func));
-      })(srcObservable) as Subscription;
-    }
-
-    request: (...value:  [...TParam] ) => Subscription;
-
-    ngOnDestroy() {
-      super.ngOnDestroy();
-    }
-
-    requestWith = (params: Observable<[...TParam]> | Signal<[...TParam]>) => {
-      if(isSignal(params)){
-        params = toObservable(params, { injector: this.injector }).pipe(notNull());
-      }
-      params.pipe(takeUntil(this.destroy$)).subscribe((p) => this.request(...p));
-      return this;
-    }
-  }
-  export class CancellationToken {}
-  export function wrapInArr<T>(sig: Signal<T>) : Signal<[T]>;
-  export function wrapInArr<T>(obs: Observable<T>): Observable<[T]>;
-  export function wrapInArr<T>(sigOrObs: Signal<T> | Observable<T>){
-    return isSignal(sigOrObs) ?
-    computed(() => [sigOrObs()])
-    : sigOrObs.pipe(map(a => [a]));
-  }

package/src/http-request-state/directives/HttpStateDirectiveBase.ts

@@ -1,29 +0,0 @@
-import { Directive, inject, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
-import { HttpRequestState } from '../types';
-import { HttpRequestStateDirective } from './request-state-directive';
-
-@Directive()
-export abstract class HttpStateDirectiveBase<V, R = null> {
-  hasView = false;
-  private injector = inject(Injector);
-  protected templateRef = inject(TemplateRef<{ $implicit: R extends null ? V : R }>);
-  protected viewContainer = inject(ViewContainerRef);
-  ngOnInit() {
-    const parent = this.injector.get(HttpRequestStateDirective);
-    if (parent == null) {
-      throw new Error('You can only use an http state directive as a child of the httpRequestState directive.');
-    }
-    parent.hooks.push(this.baseRender);
-    this.baseRender(parent.ViewContext.state);
-  }
-
-  private baseRender = (state: HttpRequestState): void => {
-    if (this.hasView) {
-      this.viewContainer.clear();
-      this.hasView = false;
-    }
-    this.hasView = this.render(state);
-  }
-
-  abstract render: (state: HttpRequestState) => boolean;
-}

package/src/http-request-state/directives/http-error-state-directive.ts

@@ -1,21 +0,0 @@
-import { Directive } from '@angular/core';
-import { isErrorState } from '../helpers';
-import { HttpRequestState } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-@Directive({ selector: '[httpErrorState]', standalone: true })
-export class HttpErrorStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-
-
-  render = (state: HttpRequestState<any>) => {
-    if (isErrorState(state)) {
-      this.viewContainer.createEmbeddedView(this.templateRef, { $implicit: state.error });
-      return true;
-    }
-    return false;
-  };
-
-  ngOnInit() {
-    super.ngOnInit();
-  }
-}

package/src/http-request-state/directives/http-inProgress-state-directive.ts

@@ -1,19 +0,0 @@
-import { Directive } from '@angular/core';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-import { HttpRequestState, HttpRequestStatus } from '../types'
-
-
-@Directive({ selector: '[httpInProgressState]', standalone: true })
-export class HttpInProgressStateDirective<V, R = null>  extends HttpStateDirectiveBase<V, R> {
-    render = (state: HttpRequestState<any>) => {
-        if(state.status === HttpRequestStatus.inProgress){
-            this.viewContainer.createEmbeddedView(this.templateRef );
-            return true;
-        }
-        return false;
-    };
-
-    ngOnInit() {
-        super.ngOnInit();
-    }
-}

package/src/http-request-state/directives/http-notStarted-state-directive.ts

@@ -1,19 +0,0 @@
-import { Directive } from '@angular/core';
-import { HttpRequestState, HttpRequestStatus } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-
-@Directive({ selector: '[httpNotStartedState]', standalone: true })
-export class HttpNotStartedStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-    render = (state: HttpRequestState<any>) => {
-        if(state.status === HttpRequestStatus.notStarted){
-            this.viewContainer.createEmbeddedView(this.templateRef );
-            return true;
-        }
-        return false;
-    };
-
-    ngOnInit() {
-        super.ngOnInit();
-    }
-}

package/src/http-request-state/directives/http-success-state-directive.ts

@@ -1,29 +0,0 @@
-import { Directive, Input } from '@angular/core';
-import { isSuccessState } from '../helpers';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-import { HttpRequestState } from '../types';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
-import { Observable } from 'rxjs';
-
-export interface HttpSuccessStateViewContext<T> {
-  $implicit: T;
-}
-@Directive({ selector: '[httpSuccessState]', standalone: true })
-export class HttpSuccessStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-  @Input() httpSuccessStateTypeSafety?: HttpRequestStateStore<any, V, R> | Observable<HttpRequestState<V>>;
-  render = (state: HttpRequestState<R extends null ? V : R>) => {
-    if (isSuccessState(state)) {
-      this.viewContainer.createEmbeddedView(this.templateRef, { $implicit: state.body });
-      return true;
-    }
-    return false;
-  };
-
-  ngOnInit() {
-    super.ngOnInit();
-  }
-
-  static ngTemplateContextGuard<V, R>(dir: HttpSuccessStateDirective<V, R>, ctx: any): ctx is HttpSuccessStateViewContext<R extends null ? V : R> {
-    return true;
-  }
-}

package/src/http-request-state/directives/request-state-directive.spec.ts

@@ -1,72 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { Component, inject } from '@angular/core';
-import { HttpRequestModule } from '../http-state-module';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
-import { Subject } from 'rxjs';
-import { RequestStateOptions } from '../types';
-
-
-@Component({
-  template: `
-    <div *httpRequestState='requestState;let state;'>
-        <ng-container *httpNotStartedState>not started</ng-container>
-        <ng-container *httpInProgressState>in progress</ng-container>
-        <ng-container *httpSuccessState='let body' >success {{body}}</ng-container>
-        <ng-container *httpErrorState='let error' >error {{error}}</ng-container>
-    </div>
-    `,
-}) export class TestHttpRequestStateDirectiveComponent {
  requestState = inject<HttpRequestStateStore<any, any>>(HttpRequestStateStore);
-
-}
-
-export class MockHttpRequestState<T> extends HttpRequestStateStore<[], T> {
-  subject = new Subject<T>();
-  constructor(options?: RequestStateOptions) {
-    super(()=> {
-      return this.subject;
-    }, options );
-  }
-}
-
-let requestState: MockHttpRequestState<string>;
-let fixture: ComponentFixture<TestHttpRequestStateDirectiveComponent>;
-
-describe('Request State Directive', () => {
-
-  beforeEach(() => {
-    requestState = new MockHttpRequestState<string>();
-    fixture = TestBed.configureTestingModule({
-      declarations: [TestHttpRequestStateDirectiveComponent],
-      providers: [{ provide: HttpRequestStateStore, useValue: requestState }],
-      imports: [HttpRequestModule]
-    }).createComponent(TestHttpRequestStateDirectiveComponent);
-  });
-
-  it('should begin with the state of not started', () => {
-    verifyText('not started');
-  });
-
-  it('should be in progress while in progress', () => {
-    requestState.request();
-    verifyText('in progress');
-  });
-
-  it('should be success when success', () => {
-    requestState.request();
-    requestState.subject.next('yay')
-    verifyText('success yay');
-  });
-
-  it('should be error when error', () => {
-    requestState.request();
-    requestState.subject.error('ouch');
-    verifyText('error ouch');
-  });
-
-  function verifyText(text:string) {
-    fixture.detectChanges();
-    const node: HTMLElement = fixture.nativeElement;
-    expect(node.innerText).toBe(text);
-  }
-
-});

package/src/http-request-state/directives/request-state-directive.ts

@@ -1,78 +0,0 @@
-import { Directive, Input, TemplateRef, ViewContainerRef, inject } from '@angular/core';
-import { defaultShareReplay } from '../../rxjs/defaultShareReplay';
-import { isObservable, Observable, Subject, Unsubscribable } from 'rxjs';
-import { map, switchAll } from 'rxjs/operators';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
-import { HttpRequestState, HttpRequestStatus } from '../types';
-
-export interface HttpRequestStateViewContext<T> {
-  $implicit?: HttpRequestStateAny<T>;
-  state?: HttpRequestStateAny<T>;
-  status: {
-    inProgress: boolean;
-    notStarted: boolean;
-    success: boolean;
-    error: boolean;
-  };
-}
-
-@Directive({ selector: '[httpRequestState]', standalone: true })
-export class HttpRequestStateDirective<TParam extends any[], V, R, T = R extends null ? V : R> {
-  private viewContainer: ViewContainerRef;
-
-  readonly ViewContext: HttpRequestStateViewContext<T> = {
-    $implicit: undefined,
-    state: undefined,
-    status: {
-      inProgress: false,
-      notStarted: true,
-      success: false,
-      error: false,
-    }
-  };
-
-
-  subject = new Subject<Observable<HttpRequestState<T>>>();
-  state = this.subject.pipe(switchAll(), defaultShareReplay());
-  subscription: Unsubscribable;
-  hooks: ((state: HttpRequestState<T>) => void)[] = [];
-
-  @Input('httpRequestState') set stateStore(store: HttpRequestStateStore<TParam, V, R, T> | Observable<HttpRequestState<T>>) {
-    if (isObservable(store)) {
-      this.subject.next(store);
-    } else {
-      this.subject.next(store.state$.pipe(map(state => state.response)));
-    }
-
-  }
-  constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef) {
-    this.viewContainer = viewContainer;
-    this.viewContainer.createEmbeddedView(templateRef, this.ViewContext);
-    this.subscription = this.state.subscribe(state => {
-      this.ViewContext.$implicit = state;
-      this.ViewContext.state = state;
-      this.ViewContext.status.inProgress = state.status === HttpRequestStatus.inProgress;
-      this.ViewContext.status.notStarted = state.status === HttpRequestStatus.notStarted;
-      this.ViewContext.status.success = state.status === HttpRequestStatus.success;
-      this.ViewContext.status.error = state.status === HttpRequestStatus.fail;
-      this.hooks.forEach(hook => hook(state));
-    });
-  }
-
-
-  ngOnDestroy() {
-    this.viewContainer.clear();
-    this.subscription.unsubscribe();
-  }
-
-  static ngTemplateContextGuard<V, R>(dir: HttpRequestStateDirective<any, V, R>, ctx: any): ctx is HttpRequestStateViewContext<R extends null ? V : R> {
-    return true;
-  }
-
-}
-
-export type HttpRequestStateAny<T> = {
-  status: HttpRequestStatus;
-  body?: T;
-  error?: any;
-}

package/src/http-request-state/helpers.ts

@@ -1,30 +0,0 @@
-import { HttpRequestState, HttpRequestStateError, HttpRequestStateInProgress, HttpRequestStateNotStarted, HttpRequestStateSuccess, HttpRequestStatus } from "./types";
-
-export function isErrorState<T>(state: HttpRequestState<T>): state is HttpRequestStateError {
-  return state.status === HttpRequestStatus.fail;
-}
-
-export function isSuccessState<T>(state: HttpRequestState<T>): state is HttpRequestStateSuccess<T> {
-  return state.status === HttpRequestStatus.success;
-}
-
-export function isSuccessOrErrorState<T>(state: HttpRequestState<T>): state is (HttpRequestStateSuccess<T> | HttpRequestStateError) {
-  return state.status === HttpRequestStatus.success || state.status === HttpRequestStatus.fail;
-}
-
-export function createSuccess<T>(body: T): HttpRequestStateSuccess<T> {
-  return { status: HttpRequestStatus.success, body };
-}
-
-export function createFailure(error: any): HttpRequestStateError {
-  return { status: HttpRequestStatus.fail, error };
-}
-
-export const notStarted: HttpRequestStateNotStarted = { status: HttpRequestStatus.notStarted };
-
-
-export const inProgress: HttpRequestStateInProgress = { status: HttpRequestStatus.inProgress };
-
-export function statusIsSuccessOrInProgress( status: HttpRequestStatus) {
-  return [HttpRequestStatus.success, HttpRequestStatus.inProgress].includes(status);
-}

package/src/http-request-state/http-request-state.ts

@@ -1,69 +0,0 @@
-import { map, startWith, switchMap } from 'rxjs/operators';
-import { getRequestorBody } from './rxjs/getRequestorBody';
-import { getRequestorStatus } from './rxjs/getRequestorState';
-import { mapError } from '../rxjs/mapError';
-import { defaultShareReplay } from '../rxjs/defaultShareReplay';
-import { Observable, of, ReplaySubject } from 'rxjs';
-import { HttpRequestFactory, HttpRequestState, HttpRequestStatus } from './types';
-import { createFailure, createSuccess, inProgress, notStarted } from './helpers';
-
-export type HttpRequestState$ <T> = Observable<HttpRequestState<T>>;
-
-export interface HttpRequestor <Res, Req> {
-  httpState$: Observable<HttpRequestState<Res>>;
-  status$: Observable<HttpRequestStatus>;
-  body$: Observable<Res>;
-  request: Req;
-}
-
-export function httpRequest<T = any>(req: Observable<T>): HttpRequestState$<T> {
-  return req.pipe(
-    map(createSuccess),
-    mapError(createFailure),
-    startWith(inProgress),
-    defaultShareReplay()
-  );
-}
-
-export function httpRequestor<TParam extends any[], T>(req: HttpRequestFactory<TParam,T> ): HttpRequestor<T, (...params: [...TParam]) => Observable<HttpRequestState<T>>> {
-  const request$ = new ReplaySubject<[...TParam]>(1);
-  const httpState$ : HttpRequestState$<T> = request$.pipe(
-    switchMap( (params) => httpRequest<T>(req(...params)) ),
-    startWith(notStarted),
-    defaultShareReplay(),
-  );
-  const request = (...params: [...TParam]) => {
-    request$.next(params);
-    return httpState$;
-  };
-  return ({
-    request,
-    httpState$,
-    body$: httpState$.pipe(getRequestorBody),
-    status$: httpState$.pipe(getRequestorStatus)
-  });
-}
-
-export function chainRequest<TParam extends any[], T, TT>(
-  httpState$: Observable<HttpRequestState<T>>,
-  request:HttpRequestFactory<TParam,TT>,
-  requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])
-  ): Observable<HttpRequestState<TT>> {
-  return httpState$.pipe(
-    switchMap( res => {
-      if(res.status === HttpRequestStatus.success) {
-        const secondReq = httpRequestor<[...TParam], TT>(request);
-        const param = requestParams(res.body);
-        secondReq.request(...param );
-        return secondReq.httpState$;
-      } else {
-        return of(res);
-      }
-    }),
-  );
-}
-
-
-
-
-

package/src/http-request-state/http-state-module.ts

@@ -1,23 +0,0 @@
-import { NgModule } from '@angular/core';
-import { HttpSuccessStateDirective } from './directives/http-success-state-directive';
-import { HttpRequestStateDirective } from './directives/request-state-directive';
-import { HttpErrorStateDirective } from './directives/http-error-state-directive';
-import { HttpInProgressStateDirective } from './directives/http-inProgress-state-directive';
-import { HttpNotStartedStateDirective } from './directives/http-notStarted-state-directive';
-
-@NgModule({
-    imports: [
-        HttpSuccessStateDirective,
-        HttpRequestStateDirective,
-        HttpErrorStateDirective,
-        HttpInProgressStateDirective,
-        HttpNotStartedStateDirective,
-    ],
-    exports: [
-        HttpSuccessStateDirective,
-        HttpRequestStateDirective,
-        HttpErrorStateDirective,
-        HttpInProgressStateDirective,
-        HttpNotStartedStateDirective,
-    ]
-}) export class HttpRequestModule { }

package/src/http-request-state/observable.spec.ts

@@ -1,43 +0,0 @@
-import { MockHttpRequestState } from "./directives/request-state-directive.spec";
-import { createSuccess, inProgress, notStarted, createFailure } from "./helpers";
-
-describe('HttpRequestStateStore', () => {
-
-    it('should begin with the state of not started',  (done) =>  {
-        const requestState = new MockHttpRequestState<string>();
-        requestState.state$.subscribe( state => {
-            expect(state).toEqual({ requestParams: null as any , response: notStarted});
-            done();
-        });
-    });
-
-    it('should be in progress when request is made',  (done) =>  {
-        const requestState = new MockHttpRequestState<string>();
-        requestState.request();
-        requestState.state$.subscribe( state => {
-            expect(state).toEqual({ requestParams: [], response: inProgress});
-            done();
-        });
-    });
-
-    it('should be in success when request completes successfully',  (done) =>  {
-        const requestState = new MockHttpRequestState<string>();
-        requestState.request();
-        requestState.subject.next('hi');
-        requestState.state$.subscribe( state => {
-            expect(state).toEqual({ requestParams: [], response: createSuccess('hi')});
-            done();
-        });
-    });
-
-    it('should be in error when request errors',  (done) =>  {
-        const requestState = new MockHttpRequestState<string>();
-        requestState.request();
-        requestState.subject.error('error');
-        requestState.state$.subscribe( state => {
-            expect(state).toEqual({ requestParams: [], response: createFailure('error') });
-            done();
-        });
-    });
-
-});

package/src/http-request-state/rxjs/getRequestorBody.ts

@@ -1,10 +0,0 @@
-import { isSuccessState } from '../helpers';
-import { HttpRequestState } from '../types';
-import { Observable } from 'rxjs';
-import { filter, map } from 'rxjs/operators';
-
-export const getRequestorBody = <T>(source: Observable<HttpRequestState<T>>) =>
-  source.pipe(
-    filter(isSuccessState),
-    map( res => res.body)
-  );

package/src/http-request-state/rxjs/getRequestorState.ts

@@ -1,8 +0,0 @@
-import { HttpRequestState } from '../types';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
-
-export const getRequestorStatus = <T>(source: Observable<HttpRequestState<T>>) =>
-  source.pipe(
-    map( res => res.status)
-  );

package/src/http-request-state/rxjs/tapError.ts

@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
-import { HttpRequestState } from '../types';
-import { isErrorState } from '../helpers';
-
-export function tapError(onError: (error: any) => void) {
-  return function (src: Observable<HttpRequestState>): Observable<HttpRequestState> {
-    return src.pipe(
-        tap( result => {
-            if(isErrorState(result)) {
-                onError(result.error);
-            }
-        })
-    );
-  };
-}

package/src/http-request-state/rxjs/tapSuccess.ts

@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
-import { HttpRequestState } from '../types';
-import { isSuccessState } from '../helpers';
-
-export function tapSuccess<T>(onSuccess: (body: T) => void) {
-  return function (src: Observable<HttpRequestState<T>>): Observable<HttpRequestState<T>> {
-    return src.pipe(
-        tap( result => {
-            if(isSuccessState(result)) {
-                onSuccess(result.body);
-            }
-        })
-    );
-  };
-}