@one-paragon/angular-utilities 1.1.8 → 1.2.1

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

@@ -1,66 +0,0 @@
-import { DestroyRef, Injectable, OnDestroy, assertInInjectionContext, inject } from "@angular/core";
-import { HttpRequestFactory, RequestStateOptions, RequestCreatorOptions } from "./types";
-import { HttpRequestStateStore } from './HttpRequestStateStore';
-import { Observable } from "rxjs";
-
-@Injectable()
-export class HttpRequestStateFactory  implements OnDestroy {
-
-  constructor() {}
-  ngOnDestroy(): void {
-    this.requestors.forEach( request => request.ngOnDestroy());
-  }
-  private requestors: OnDestroy[] = [];
-
-  create<TParam extends any[], V>( req: HttpRequestFactory<TParam, V>, options?: RequestStateOptions<TParam>) : HttpRequestStateStore<TParam, V>
-  create<TParam extends any[], V, R, T = R>( req: HttpRequestFactory<TParam, V>, project: (v: V) => R , options?: RequestStateOptions<TParam>) : HttpRequestStateStore<TParam, V, T>
-  create<TParam extends any[], V, R = null, T = R extends null ? V : R>( req: HttpRequestFactory<TParam, V>, optionsOrProject?: RequestStateOptions<TParam> | ((v: V) => R), options?: RequestStateOptions<TParam> ) : HttpRequestStateStore<TParam, V, R, T> {
-    const requestor = (typeof(optionsOrProject) === 'function' ?  new HttpRequestStateStore<TParam, V, R, T>(req, options, optionsOrProject) : new HttpRequestStateStore<TParam, V, R, T>(req, options));
-    this.requestors.push(requestor);
-    return requestor;
-  }
-
-  createHttpClient<T>( r: (o: Observable<T> ) => Observable<T> , options?: RequestStateOptions<any> )  {
-    const requestor = new HttpRequestStateStore(r, options);
-    this.requestors.push(requestor);
-    return requestor;
-  }
-
-}
-
-export function createRequestor<TParam extends any[], V>( req: HttpRequestFactory<TParam, V>, options?: RequestCreatorOptions<TParam>) : HttpRequestStateStore<TParam, V>
-export function createRequestor<TParam extends any[], V, R, T = R>( req: HttpRequestFactory<TParam, V>, project: (v: V) => R , options?: RequestCreatorOptions<TParam>) : HttpRequestStateStore<TParam, V, T>
-export function createRequestor<TParam extends any[], V, R = null, T = R extends null ? V : R>( req: HttpRequestFactory<TParam, V>, optionsOrProject?: RequestCreatorOptions<TParam> | ((v: V) => R), options?: RequestCreatorOptions<TParam> ) : HttpRequestStateStore<TParam, V, R, T>{
-
-  const ops  = isFunction(optionsOrProject) ? options : optionsOrProject;
-
-  const destroyRef = getDestroyRef(ops);
-
-  const requestStore = typeof(optionsOrProject) === 'function' ?  
-    new HttpRequestStateStore<TParam, V, R, T>(req, options, optionsOrProject)
-    : new HttpRequestStateStore<TParam, V, R, T>(req, optionsOrProject);
-
-  destroyRef.onDestroy(() => requestStore?.ngOnDestroy());
-
-  return requestStore;
-}
-
-function isFunction(value: any): value is Function {
-  return typeof value === 'function';
-}
-
-function getDestroyRef(options?: RequestCreatorOptions<any>){
-  const providedInjector = options?.injector;
-
-  if(!providedInjector){
-    try {
-      assertInInjectionContext(createRequestor);
-    } catch (error) {
-      throw new Error('createRequestor() must be used in an Injection Context or you must provide an injector to createRequestor()');
-    }
-  }
-
-  const destroyRef = providedInjector?.get(DestroyRef) || inject(DestroyRef);
-
-  return destroyRef;
-}

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

@@ -1,151 +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, tap } from 'rxjs/operators';
-import { HttpErrorResponse } from '@angular/common/http';
-import { mapError } from '../rxjs/mapError';
-import { defaultShareReplay } from '../rxjs/defaultShareReplay';
-import { Directive } from '@angular/core';
-
-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>> {
-
-    constructor(private req: HttpRequestFactory<TParam, V> ,private options?: RequestStateOptions<TParam>, private project?: (v: V) => R) {
-      super({ requestParams: null as any, response: notStarted });
-      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();
-    }
-
-  }
-
-  export class CancellationToken {}

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

@@ -1,38 +0,0 @@
-import { Directive, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
-import { HttpRequestState } from '../types';
-import { HttpRequestStateDirective } from './request-state-directive';
-
-@Directive()
-export abstract class HttpStateDirectiveBase {
-    hasView = false;
-    constructor(
-        private injector: Injector,
-        protected templateRef: TemplateRef<any>,
-        protected viewContainer: 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);
-    }
-
-    ngOnDestroy() {
-        
-    }
-
-    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,32 +0,0 @@
-import { Directive, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
-import { isErrorState } from '../helpers';
-import { HttpRequestState } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-@Directive({ selector: '[httpErrorState]', standalone: true })
-export class HttpErrorStateDirective<TParam extends any[], T> extends HttpStateDirectiveBase {
-
-  constructor(
-    injector: Injector,
-    templateRef: TemplateRef<any>,
-    viewContainer: ViewContainerRef,
-  ) {
-    super(injector, templateRef, viewContainer);
-  }
-
-  render = (state: HttpRequestState<any>) => {
-    if (isErrorState(state)) {
-      this.viewContainer.createEmbeddedView(this.templateRef, { $implicit: state.error });
-      return true;
-    }
-    return false;
-  };
-
-  ngOnInit() {
-    super.ngOnInit();
-  }
-
-  ngOnDestroy() {
-    super.ngOnDestroy();
-  }
-}

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

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

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

@@ -1,31 +0,0 @@
-import { Directive, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
-import { HttpRequestState, HttpRequestStatus } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-
-@Directive({ selector: '[httpNotStartedState]', standalone: true })
-export class HttpNotStartedStateDirective<TParam extends any[],T> extends HttpStateDirectiveBase {
-    render = (state: HttpRequestState<any>) => {
-        if(state.status === HttpRequestStatus.notStarted){
-            this.viewContainer.createEmbeddedView(this.templateRef );
-            return true;
-        }
-        return false;
-    };
-
-    constructor(
-        injector: Injector,
-        templateRef: TemplateRef<any>,
-        viewContainer: ViewContainerRef,
-    ) {
-        super(injector,templateRef,viewContainer);
-    }
-
-    ngOnInit() {
-        super.ngOnInit();
-    }
-
-    ngOnDestroy() {
-        super.ngOnDestroy();
-    }
-}

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

@@ -1,40 +0,0 @@
-import { Directive, Injector, Input, TemplateRef, ViewContainerRef } 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 {
-  @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;
-  };
-  constructor(
-    injector: Injector,
-    templateRef: TemplateRef<{ $implicit: R extends null ? V : R }>,
-    viewContainer: ViewContainerRef,
-  ) {
-    super(injector, templateRef, viewContainer);
-  }
-
-  ngOnInit() {
-    super.ngOnInit();
-  }
-
-  ngOnDestroy() {
-    super.ngOnDestroy();
-  }
-
-  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 } 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 {
-  constructor(public requestState: HttpRequestStateStore<any, any>) { }
-}
-
-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,79 +0,0 @@
-import { Directive, Input, TemplateRef, ViewContainerRef } 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> {
-
-  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(
-    private templateRef: TemplateRef<any>,
-    private viewContainer: ViewContainerRef,
-  ) {
-    this.viewContainer.createEmbeddedView(this.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 { }