@one-paragon/angular-utilities 2.1.5 → 2.1.7

package/karma.conf.js

@@ -1,44 +0,0 @@
-// Karma configuration file, see link for more information
-// https://karma-runner.github.io/1.0/config/configuration-file.html
-
-module.exports = function (config) {
-  config.set({
-    basePath: '',
-    frameworks: ['jasmine', '@angular-devkit/build-angular'],
-    plugins: [
-      require('karma-jasmine'),
-      require('karma-chrome-launcher'),
-      require('karma-jasmine-html-reporter'),
-      require('karma-coverage'),
-      require('@angular-devkit/build-angular/plugins/karma')
-    ],
-    client: {
-      jasmine: {
-        // you can add configuration options for Jasmine here
-        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
-        // for example, you can disable the random execution with `random: false`
-        // or set a specific seed with `seed: 4321`
-      },
-      clearContext: false // leave Jasmine Spec Runner output visible in browser
-    },
-    jasmineHtmlReporter: {
-      suppressAll: true // removes the duplicated traces
-    },
-    coverageReporter: {
-      dir: require('path').join(__dirname, '../../coverage/http-request-state'),
-      subdir: '.',
-      reporters: [
-        { type: 'html' },
-        { type: 'text-summary' }
-      ]
-    },
-    reporters: ['progress', 'kjhtml'],
-    port: 9876,
-    colors: true,
-    logLevel: config.LOG_INFO,
-    autoWatch: true,
-    browsers: ['Chrome'],
-    singleRun: false,
-    restartOnFileChange: true
-  });
-};

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../dist/angular-utilities",
-  "lib": {
-    "entryFile": "src/public-api.ts"
-  }
-}

package/src/action-state/action-state-spinner/action-state-spinner.component.css

@@ -1,16 +0,0 @@
-#blocker {
-  position:fixed;
-  top: 0px;
-  left: 0px;
-  width:100%;
-  height:100%;
-  background-color:rgba(14, 13, 13, 0.411);
-  z-index:999999;
-}
-
-.spinner{
-  position: absolute;
-  top:50%;
-  left:40%;
-  transform: translate(-50%, -50%);
-}

package/src/action-state/action-state-spinner/action-state-spinner.component.html

@@ -1,6 +0,0 @@
-@if((serverActionStatus$ | async)?.status === serverStatusTypes.inProgress){
-  <div id="blocker">
-    <mat-spinner class="spinner" [diameter]="200" />
-  </div>
-}
-

package/src/action-state/action-state-spinner/action-state-spinner.component.spec.ts

@@ -1,25 +0,0 @@
-import { async, ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { ActionStateSpinnerComponent } from './action-state-spinner.component';
-
-describe('ActionStateSpinnerComponent', () => {
-  let component: ActionStateSpinnerComponent;
-  let fixture: ComponentFixture<ActionStateSpinnerComponent>;
-
-  beforeEach(async(() => {
-    TestBed.configureTestingModule({
-      declarations: [ ActionStateSpinnerComponent ]
-    })
-    .compileComponents();
-  }));
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(ActionStateSpinnerComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

package/src/action-state/action-state-spinner/action-state-spinner.component.ts

@@ -1,25 +0,0 @@
-import { Component, OnInit, Input } from '@angular/core';
-import { Observable } from 'rxjs';
-import { ActionStatus, serverStatusTypes } from '../ngrx';
-import { delayOn } from '../../rxjs';
-import { AsyncPipe } from '@angular/common';
-import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-
-@Component({
-  selector: 'lib-action-state-spinner',
-  templateUrl: './action-state-spinner.component.html',
-  styleUrls: ['./action-state-spinner.component.css'],
-    imports: [AsyncPipe, MatProgressSpinnerModule]
-})
-export class ActionStateSpinnerComponent implements OnInit {
-
-  @Input() status$!: Observable<ActionStatus>;
-  serverActionStatus$!: Observable<ActionStatus>;
-  serverStatusTypes = serverStatusTypes;
-
-  ngOnInit() {
-    this.serverActionStatus$ = this.status$.pipe(
-      delayOn( a => a.status === serverStatusTypes.inProgress , 500)
-    );
-  }
-}

package/src/action-state/action-state-ui/action-state-ui.module.ts

@@ -1,13 +0,0 @@
-import { NgModule } from '@angular/core';
-import { ActionStateSpinnerComponent } from '../action-state-spinner/action-state-spinner.component';
-
-
-@NgModule({
-  imports: [
-    ActionStateSpinnerComponent,
-  ],
-  exports: [
-    ActionStateSpinnerComponent,
-  ]
-})
-export class ActionStateUiModule { }

package/src/action-state/ngrx-ext/ngrx-ext.module.ts

@@ -1,15 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { actionStatusReducer } from '../ngrx';
-import { StoreModule } from '@ngrx/store';
-
-
-
-@NgModule({
-  declarations: [],
-  imports: [
-    CommonModule,
-    StoreModule.forFeature('ActionStatus', actionStatusReducer),
-  ]
-})
-export class NgrxExtModule { }

package/src/action-state/ngrx.ts

@@ -1,69 +0,0 @@
-import { Action, createFeatureSelector, createSelector } from '@ngrx/store';
-import { createEntityAdapter, EntityState } from '@ngrx/entity';
-import { get } from 'lodash';
-
-// State
-export class AppStatusState {
-  readonly ActionStatusBar!: ActionStatus[];
-}
-
-export interface StatusState {
-  ids: string[];
-  entities: {[id: string]: ActionStatus};
-}
-
-export class ActionStatus {
-  id!: string;
-  displayName?: string;
-  status!: serverStatusTypes;
-  responsePayload?: any;
-}
-
-const InitialState: StatusState = {
-  ids: [],
-  entities: {}
-};
-
-export enum serverStatusTypes {
-  notStarted = 0,
-  inProgress = 1,
-  success = 2,
-  error = 3
-}
-
-// Entity and Selectors
-export const statusAdapter = createEntityAdapter<ActionStatus>();
-export interface State extends EntityState<ActionStatus> {}
-export const initialState: StatusState = statusAdapter.getInitialState(InitialState);
-
-export const getStatusState = createFeatureSelector<State>('ActionStatus');
-export const {
-  selectIds,
-  selectEntities,
-  selectAll,
-  selectTotal
-} = statusAdapter.getSelectors(getStatusState);
-
-export const selectEntity = (id: string) => createSelector(
-  selectEntities,
-  (entities: any)  => entities[id]
-);
-
-// Reducers
-export function actionStatusReducer(state: StatusState = initialState, action: Action) {
-
-  const actionStatus: ActionStatus = get(action, 'payload.actionStatus' ) as any;
-
-  if ( actionStatus ) {
-    if ( state.ids.find(id => id === actionStatus.id) ) {
-      const modifiedObj = {...state.entities[actionStatus.id] };
-      modifiedObj.status = actionStatus.status;
-      modifiedObj.responsePayload = actionStatus.responsePayload;
-      return statusAdapter.upsertOne( modifiedObj, state);
-    } else {
-      return statusAdapter.addOne(actionStatus , state);
-    }
-
-  }
-  return state;
-}

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

@@ -1,56 +0,0 @@
-import { Injectable, Injector, OnDestroy, assertInInjectionContext, inject, runInInjectionContext } from "@angular/core";
-import { RequestFactory, RequestStateOptions, RequestCreatorOptions } from "./types";
-import { RequestStateStore } from './RequestStateStore';
-import { Observable } from "rxjs";
-
-@Injectable()
-export class RequestStateFactory  implements OnDestroy {
-
-  constructor() {}
-  ngOnDestroy(): void {
-    this.requestors.forEach( request => request.destroy());
-  }
-  private requestors: RequestStateStore<any, any, any>[] = [];
-
-  create<TParam extends any[], V>( req: RequestFactory<TParam, V>, options?: RequestStateOptions<TParam>) : RequestStateStore<TParam, V>
-  create<TParam extends any[], V, R, T = R>( req: RequestFactory<TParam, V>, project: (v: V) => R , options?: RequestStateOptions<TParam>) : RequestStateStore<TParam, V, T>
-  create<TParam extends any[], V, R = null, T = R extends null ? V : R>(req: RequestFactory<TParam, V>, optionsOrProject?: RequestStateOptions<TParam> | ((v: V) => R), options?: RequestStateOptions<TParam> ) : RequestStateStore<TParam, V, R, T> {
-    const requestor = (typeof(optionsOrProject) === 'function' ?  new RequestStateStore<TParam, V, R, T>(req, options, optionsOrProject) : new RequestStateStore<TParam, V, R, T>(req, optionsOrProject));
-    this.requestors.push(requestor);
-    return requestor;
-  }
-
-  createHttpClient<T>( r: (o: Observable<T> ) => Observable<T> , options?: RequestStateOptions<any> )  {
-    const requestor = new RequestStateStore(r, options);
-    this.requestors.push(requestor);
-    return requestor;
-  }
-}
-
-export function createRequestor<TParam extends any[], V>( req: RequestFactory<TParam, V>, options?: RequestCreatorOptions<TParam>) : RequestStateStore<TParam, V>
-export function createRequestor<TParam extends any[], V, R, T = R>( req: RequestFactory<TParam, V>, project: (v: V) => R , options?: RequestCreatorOptions<TParam>) : RequestStateStore<TParam, V, T>
-export function createRequestor<TParam extends any[], V, R = null, T = R extends null ? V : R>( req: RequestFactory<TParam, V>, optionsOrProject?: RequestCreatorOptions<TParam> | ((v: V) => R), options?: RequestCreatorOptions<TParam> ) : RequestStateStore<TParam, V, R, T>{
-  const ops  = typeof(optionsOrProject) === 'function' ? options : optionsOrProject;
-  const injector = getInjector(ops);
-  return runInInjectionContext(injector, () => {
-    const requestStore = typeof(optionsOrProject) === 'function' ?  
-      new RequestStateStore<TParam, V, R, T>(req, options, optionsOrProject)
-      : new RequestStateStore<TParam, V, R, T>(req, optionsOrProject);
-
-    return requestStore;
-  })
-}
-
-function getInjector(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()');
-    }
-  }
-
-  return providedInjector ?? inject(Injector);
-}

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

@@ -1,284 +0,0 @@
-import { combineLatest, Observable, of, pipe, Subject, Subscription } from 'rxjs';
-import { RequestFactory as RequestFactory, RequestStrategy as RequestStrategy, RequestStatus, RequestState, RequestStateOptions, RequestStateCancelled } 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 { assertInInjectionContext, computed, DestroyRef, inject, InjectionToken, Injector, isSignal, signal, 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: RequestState<T>;
-}
-
-export class RequestStateStore<TParam extends any[], V, R = null, T = R extends null ? V : R> {
-  private _state = signal<RequestResponse<TParam, T>>({ requestParams: null as any, response: notStarted });
-  private setState = (state: RequestResponse<TParam, T>) => this._state.set(state);
-  state = this._state.asReadonly();
-  state$ = toObservable(this.state);
-  private options?: RequestStateOptions;
-  private project?: (v: V) => R;
-  private req: RequestFactory<TParam, V>;
-  private injector = inject(Injector)
-  private destroy$ = new Subject<void>();
-  private defaultErrorHandling?: (e?: any) => void;
-  private _useDefaultErrorHandler?: boolean;
-  private defaultSuccessHandling?: (e?: T) => void;
-  
-  constructor(req: RequestFactory<TParam, V> ,options?: RequestStateOptions<TParam>, project?: (v: V) => R) {
-    this.assertInjectionContext();
-    this.injector.get(DestroyRef).onDestroy(() => this.destroy$.next());
-
-    this.project = project;
-    this.options = options;
-    this.req = req;
-
-    const config = inject(RequestStateStoreConfigToken, { optional: true});
-    if(config){
-      this.defaultErrorHandling = config.defaultErrorHandling;
-      this._useDefaultErrorHandler = config.useDefaultErrorHandler;
-      this.defaultSuccessHandling = config.defaultSuccessHandling;
-
-      if(this._useDefaultErrorHandler){
-        this.subscriber(this.selectError$, e => {
-          if(!this.errorHandled){
-            this.#onDefaultErrorHandling(e);
-          }
-        })
-      }
-    }
-
-    this.request = (this.options?.strategy === RequestStrategy.singleUse) ? this.singleUseRequest :  this.flattenedRequest;
-    if(options?.autoRequest){
-      (this.request as any)();
-    }
-  }
-
-  reset() {
-    this._state.set({ requestParams:null as any, response: notStarted });
-  }
-
-  private flatteningStrategy = () => {
-    if(this.options?.strategy === RequestStrategy.concurrent)
-      return mergeMap( (params: [...TParam]) => this.createRequest(...params));
-
-    if(this.options?.strategy === RequestStrategy.sequential)
-      return concatMap( (params: [...TParam]) => this.createRequest(...params));
-
-    return switchMap( (params: [...TParam]) => ((params[0] as any) instanceof CancellationToken) ?
-      of({ requestParams: params[0], response: { status: RequestStatus.cancelled } as RequestStateCancelled } ) : this.createRequest(...params) );
-  }
-
-  private createRequestPipeline = () => {
-    const origin$ = new Subject<[...TParam]>();
-    const sub = origin$.pipe(
-      this.flatteningStrategy(),
-      tap<RequestResponse<TParam, T>>(state => this.setState(state)),
-      pipe(takeUntil(this.destroy$))
-    ).subscribe();
-    return (params: [...TParam]) => {
-      origin$.next(params);
-      return sub;
-    }
-  }
-
-  private requestPipeLine = this.createRequestPipeline();
-
-  private flattenedRequest = (...value: [...TParam]) => {
-    return this.requestPipeLine(value);
-  }
-  private singleUseRequest = (...value: [...TParam]) => {
-    if (this.state().response.status !== RequestStatus.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.requestPipeLine(value);
-  }
-
-  $selectRequestState = computed(() => this.state().response);
-  selectRequestState$ = this.state$.pipe(map(s => s.response));
-  /**
-   * @deprecated use selectRequestState$ instead
-   */
-  selectHttpState$ = this.selectRequestState$;
-  $selectStatus = computed(() => this.$selectRequestState()?.status);
-  selectStatus$ = this.selectRequestState$.pipe(map(s => s.status));
-  $isSuccess = computed(() => isSuccessState(this.$selectRequestState()));
-  $isError = computed(() => isErrorState(this.$selectRequestState()));
-  $isInProgress = computed(() => this.$selectStatus() === RequestStatus.inProgress);
-  $isNotStarted = computed(() => this.$selectStatus() === RequestStatus.notStarted);
-
-  selectError$ = this.selectRequestState$.pipe(
-    filter(isErrorState),
-    map(state => state.error)
-  );
-
-  $selectError = computed(() => {
-    const state = this.$selectRequestState();
-    if(isErrorState(state)) return state.error
-  })
-
-  selectResponse$: Observable<T> = this.selectRequestState$.pipe(
-    filter(isSuccessState),
-    map( state => state.body)
-  );
-
-  $selectResponse = computed(() => {
-    const state = this.$selectRequestState();
-    if(isSuccessState(state)){
-      return state.body
-    }
-    return undefined;
-  })
-
-  private selectSuccessOrError$: Observable<void> = this.state$.pipe(
-    map(r => r.response),
-    filter(isSuccessOrErrorState),
-    map(() => undefined)
-  );
-
-  errorHandled = false;
-  onError( cb: (error: HttpErrorResponse) => void) {
-    this.errorHandled = true;
-    this.subscriber(this.selectError$, cb);
-    return this;
-  }
-
-  #onDefaultErrorHandling = (e: any) => {
-    if(this.defaultErrorHandling) this.defaultErrorHandling(e)
-    else console.error(e)
-  }
-  /**
-   * if no handler was provided will call `console.error`
-   */
-  useDefaultErrorHandler(){
-    this.subscriber(this.selectError$, this.#onDefaultErrorHandling);
-    return this;
-  }
-
-  /**
-   * if no handler was provided will call `console.log` with 'Success'
-   */
-  useDefaultSuccessHandler(){
-    this.subscriber(this.selectResponse$,  this.defaultSuccessHandling || (() => console.log('Success')));
-    return this;
-  }
-
-  onSuccess( cb: (body?: T) => void) {
-    this.subscriber(this.selectResponse$, cb);
-    return this;
-  }
-
-  onSuccessOrError(cb: () => void){
-    this.subscriber(this.selectSuccessOrError$, cb);
-    return this;
-  }
-
-  onSuccessWithRequest(
-    func: (state: { requestParams: [...TParam]; body: T; }) => void
-  ) {
-    this.subscriber(this.state$,
-      ({ requestParams, response }) => {
-
-        if(isSuccessState(response)) func({requestParams,body: response.body});
-      }
-    );
-    return this;
-  }
-
-  onErrorWithRequest(
-    func: (state: { error: HttpErrorResponse; requestParams: [...TParam]; }) => void
-  ) {
-    this.errorHandled = true;
-    this.subscriber(this.state$,
-      ({ 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()
-    );
-  }
-
-  private subscriber = <V>(srcObservable: Observable<V>, func: (obj: V) => void): Subscription => {
-    return srcObservable.pipe(tap(func), takeUntil(this.destroy$)).subscribe();
-  }
-
-  /**
-   * @deprecated use the standalone subscriber helper function
-   */
-  on = this.subscriber;
-  request: (...value:  [...TParam] ) => Subscription;
-
-  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;
-  }
-
-  private assertInjectionContext(){
-    try {
-      assertInInjectionContext(RequestStateStore);
-    } catch (error) {
-      throw new Error('RequestStateStore must be created in an Injection Context');
-    };
-  }
-
-  destroy() {
-    this.destroy$.next();
-  }
-}
-export class CancellationToken {}
-
-export function wrapInArr<T extends [Signal<any>, ...Signal<any>[]]>(...sigs: T) : Signal<{ [K in keyof T]: T[K] extends Signal<infer U> ? U : never }>;
-export function wrapInArr<T extends [Observable<any>, ...Observable<any>[]]>(...obs: T): Observable<{ [K in keyof T]: T[K] extends Observable<infer U> ? U : never }>;
-/**
- * If any values from the array of signals or observables are null or undefined, all values will be filtered
- */
-export function wrapInArr<T extends Signal<any>[] | Observable<any>[]>(...sigOrObs: T){
-  if(isSignal(sigOrObs[0])){
-    return computed(() => {
-      const arr = (sigOrObs as Signal<T>[]).map(s => s()) as { [K in keyof T]: T[K] extends Signal<infer U> ? U : never };
-      if(arr.some(s => s == undefined)) return undefined;
-      return arr;
-    });
-  }
-  else {
-    return combineLatest(sigOrObs as Observable<any>[]).pipe(filter(vals => vals.every(val=> val != undefined))) as Observable<{ [K in keyof T]: T[K] extends Observable<infer U> ? U : never }>;
-
-  }
-}
-
-export interface RequestStateStoreConfig {
-  /**
-   * if `useDefaultErrorHandler` is `true` this will run on each error if no other handler provided.
-   * else can be used by call `.useDefaultHandler`
-   */
-  defaultErrorHandling?: (e?: any) => void;
-  /**
-   * if `useDefaultErrorHandler` is `true` `defaultErrorHandling` will run on each error if no other handler provided.
-   */
-  useDefaultErrorHandler?: boolean;
-
-  /**
-   * will be called if `useDefaultSuccess` is used
-   */
-  defaultSuccessHandling?: <T>(e?: T) => void;
-}
-
-export const RequestStateStoreConfigToken = new InjectionToken<RequestStateStoreConfig>('RequestStateConfig');
-

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

@@ -1,29 +0,0 @@
-import { Directive, inject, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
-import { RequestState } 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: RequestState): void => {
-    if (this.hasView) {
-      this.viewContainer.clear();
-      this.hasView = false;
-    }
-    this.hasView = this.render(state);
-  }
-
-  abstract render: (state: RequestState) => 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 { RequestState } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-@Directive({ selector: '[httpErrorState]', })
-export class HttpErrorStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-
-
-  render = (state: RequestState<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 { RequestState, RequestStatus } from '../types'
-
-
-@Directive({ selector: '[httpInProgressState]', })
-export class HttpInProgressStateDirective<V, R = null>  extends HttpStateDirectiveBase<V, R> {
-    render = (state: RequestState<any>) => {
-        if(state.status === RequestStatus.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 { RequestState, RequestStatus } from '../types';
-import { HttpStateDirectiveBase } from './HttpStateDirectiveBase';
-
-
-@Directive({ selector: '[httpNotStartedState]', })
-export class HttpNotStartedStateDirective<V, R = null> extends HttpStateDirectiveBase<V, R> {
-    render = (state: RequestState<any>) => {
-        if(state.status === RequestStatus.notStarted){
-            this.viewContainer.createEmbeddedView(this.templateRef );
-            return true;
-        }
-        return false;
-    };
-
-    ngOnInit() {
-        super.ngOnInit();
-    }
-}