@one-paragon/angular-utilities 2.2.5 → 2.2.6

package/karma.conf.js

@@ -0,0 +1,44 @@
+// 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

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

package/package.json

@@ -1,27 +1,15 @@
-{
-  "name": "@one-paragon/angular-utilities",
-  "version": "2.2.5",
-  "peerDependencies": {
-    "@angular/common": "19.2.1",
-    "@angular/core": "19.2.1",
-    "@angular/material": "19.2.1",
-    "@ngrx/component-store": "19.0.1",
-    "@ngrx/effects": "19.0.1",
-    "@ngrx/store": "19.0.1"
-  },
-  "dependencies": {
-    "tslib": "2.8.1"
-  },
-  "module": "fesm2022/one-paragon-angular-utilities.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/one-paragon-angular-utilities.mjs"
-    }
-  },
-  "sideEffects": false
-}
+{
+  "name": "@one-paragon/angular-utilities",
+  "version": "2.2.6",
+  "peerDependencies": {
+    "@angular/common": "19.2.1",
+    "@angular/core": "19.2.1",
+    "@angular/material": "19.2.1",
+    "@ngrx/component-store": "19.0.1",
+    "@ngrx/effects": "19.0.1",
+    "@ngrx/store": "19.0.1"
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  }
+}

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

@@ -0,0 +1,16 @@
+#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

@@ -0,0 +1,7 @@
+@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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,25 @@
+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

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

package/{action-state/index.d.ts → src/action-state/index.ts}

@@ -1,4 +1,8 @@
-export * from './ngrx';
-export * from './ngrx-ext/ngrx-ext.module';
-export * from './action-state-ui/action-state-ui.module';
-export * from './action-state-spinner/action-state-spinner.component';
+/*
+ * Public API Surface of action-state
+ */
+
+export * from './ngrx';
+export * from './ngrx-ext/ngrx-ext.module';
+export * from './action-state-ui/action-state-ui.module';
+export * from './action-state-spinner/action-state-spinner.component';

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,284 @@
+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/{http-request-state/deprecated.d.ts → src/http-request-state/deprecated.ts}

@@ -1,20 +1,20 @@
-/**
- * @deprecated use RequestStateFactory
- */
-export { RequestStateFactory as HttpRequestStateFactory } from './RequestStateFactory';
-/**
- * @deprecated use RequestStatus
- */
-export { RequestStatus as HttpRequestStatus } from './types';
-/**
- * @deprecated use RequestState
- */
-export type { RequestState as HttpRequestState } from './types';
-/**
- * @deprecated use RequestStateStore
- */
-export { RequestStateStore as HttpRequestStateStore } from './RequestStateStore';
-/**
- * @deprecated use RequestStrategy
- */
-export { RequestStrategy as HttpRequestStrategy } from './types';
+/**
+ * @deprecated use RequestStateFactory
+ */
+export { RequestStateFactory as HttpRequestStateFactory } from './RequestStateFactory';
+/**
+ * @deprecated use RequestStatus
+ */
+export { RequestStatus as HttpRequestStatus } from './types';
+/**
+ * @deprecated use RequestState
+ */
+export type { RequestState as HttpRequestState } from './types'
+/**
+ * @deprecated use RequestStateStore
+ */
+export { RequestStateStore as HttpRequestStateStore } from './RequestStateStore';
+/**
+ * @deprecated use RequestStrategy
+ */
+export { RequestStrategy as HttpRequestStrategy } from './types';