@one-paragon/angular-utilities 2.8.4 → 2.8.5

package/karma.conf.js

@@ -1,43 +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')
-    ],
-    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,7 +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,26 +0,0 @@
-import { Component, OnInit, Input, ChangeDetectionStrategy } 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],
-  changeDetection: ChangeDetectionStrategy.OnPush
-})
-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/index.ts

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

@@ -1,14 +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,360 +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, effect, inject, InjectionToken, Injector, isSignal, signal, Signal, untracked } 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 });
-  state = this._state.asReadonly();
-  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.effectOnState('error', e => {
-          if(!this.errorHandled){
-            this.#onDefaultErrorHandling(e.error);
-          }
-        })
-      }
-    }
-
-    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._state.set(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);
-
-  $selectStatus = computed(() => this.$selectRequestState()?.status);
-  $isSuccess = computed(() => isSuccessState(this.$selectRequestState()));
-  $isError = computed(() => isErrorState(this.$selectRequestState()));
-  $isInProgress = computed(() => this.$selectStatus() === RequestStatus.inProgress);
-  $isNotStarted = computed(() => this.$selectStatus() === RequestStatus.notStarted);
-
-  $selectError = computed(() => {
-    const state = this.$selectRequestState();
-    if(isErrorState(state)) return state.error
-  });
-
-  $selectResponse = computed(() => {
-    const state = this.$selectRequestState();
-    if(isSuccessState(state)){
-      return state.body
-    }
-    return undefined;
-  });
-
-  errorHandled = false;
-  onError( cb: (error: HttpErrorResponse) => void) {
-    this.errorHandled = true;
-    this.effectOnState('error', cb);
-    return this;
-  }
-
-  onErrorResponse( cb: (error: HttpErrorResponse, ...requestParams: [...TParam]) => void) {
-    this.errorHandled = true;
-    this.effectOnState('error', (e, p) => cb(e, ...p));
-    return this;
-  }
-
-  onErrorRequest( cb: ( ...requestParams: [...TParam]) => void) {
-    this.errorHandled = true;
-    this.effectOnState('error', (_, p) => cb(...p));
-    return this;
-  }
-
-  onErrorWithRequest(
-    func: (state: { error: HttpErrorResponse; requestParams: [...TParam]; }) => void
-  ) {
-    this.errorHandled = true;
-    this.effectOnState('error', (error, requestParams) => func({ requestParams, error }));
-
-    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.effectOnState('error', this.#onDefaultErrorHandling);
-    return this;
-  }
-
-
-  /**
-   * if no handler was provided will call `console.log` with 'Success'
-   */
-  useDefaultSuccessHandler(){
-    this.effectOnState('success', this.defaultSuccessHandling || (() => console.log('Success')));
-    return this;
-  }
-
-  onSuccess( cb: (response?: T) => void) {
-    this.effectOnState('success only', cb);
-    return this;
-  }
-
-  onSuccessResponse( cb: (response: T, ...requestParams: [...TParam]) => void) {
-    this.effectOnState('success', (response, requestParams) => cb(response, ...requestParams));
-    return this;
-  }
-
-  onSuccessWithRequest(
-    func: (state: { requestParams: [...TParam]; body: T; }) => void
-  ) {
-    this.effectOnState('success', (body, requestParams) => func({ requestParams, body }));
-    return this;
-  }
-
-  onSuccessRequest( cb: ( ...requestParams: [...TParam]) => void) {
-    this.effectOnState('success', (_, requestParams) => cb(...requestParams));
-    return this;
-  }
-
-  onSuccessOrError(cb: () => void){
-    this.effectOnState('both', cb);
-    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 effectOnState(onState: 'success only', func: (obj: T) => void): void;
-  private effectOnState(onState: 'success', func: (obj: T, params: [...TParam]) => void): void;
-  private effectOnState(onState: 'error', func: (obj: any, params: [...TParam]) => void): void;
-  private effectOnState(onState: 'both', func: () => void): void;
-  private effectOnState(
-    onState: 'error' | 'success' | 'both' | 'success only',
-    func: any): void {
-    effect(() => {
-      const { requestParams, response } = this.state();
-      switch (onState) {
-        case 'error':
-          if(isErrorState(response)) untracked(() => (func as (obj: any, params?: [...TParam]) => void)(response.error, requestParams));
-          break;
-        case 'success':
-          if(isSuccessState(response)) untracked(() => (func as (obj: T, params?: [...TParam]) => void)(response.body, requestParams));
-          break;
-        case 'success only':
-          if(isSuccessState(response)) untracked(() => (func as (obj: T) => void)(response.body));
-          break;
-        case 'both':
-          if(isSuccessOrErrorState(response)) untracked(() => (func as () => void)());
-          break;
-      }
-    }, { injector: this.injector })
-  }
-
-  /**
-   * @deprecated use the standalone subscriber helper function
-   */
-  on = <V>(srcObservable: Observable<V>, func: (obj: V) => void): Subscription => {
-    return srcObservable.pipe(tap(func), takeUntil(this.destroy$)).subscribe();
-  }
-  request: (...value: [...TParam] ) => Subscription;
-
-  /**
-   * @param params An observable or signal that returns an array to be spread into the request function.
-   * If undefined is returned, the request will not be made.
-   */
-  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;
-  }
-
-  /**
-   * @param params The parameters to be passed to the request function.
-   * The parameters can be either actual values or wrapped in a signal.
-   * If any of the parameters are a signal, it will be unwrapped and passed to the request.
-   * It will be tracked and the request will be made whenever its value changes.
-   * If any of the signals return undefined, the request will not be made.
-   */
-  requestOn = (...params: SignalOrValArr<TParam>) => {
-    const paramsArr = computed(() => {
-      const p = params.map(param =>
-        isSignal(param)
-          ? ({ param, isSignal: true })
-          : ({ param, isSignal: false })
-      );
-      const allVals = p.every(({ param, isSignal }) => !isSignal || param() != undefined);
-      if(allVals) return p.map(({ param, isSignal }) => isSignal ? param() : param);
-      return undefined;
-    });
-    effect(() => {
-      const vals = paramsArr();
-      untracked(() => {
-        if(vals) this.request(...vals as [...TParam]);
-      });
-    }, { injector: this.injector });
-    return this;
-  };
-
-  private assertInjectionContext(){
-    try {
-      assertInInjectionContext(RequestStateStore);
-    } catch (error) {
-      throw new Error('RequestStateStore must be created in an Injection Context');
-    }
-  }
-
-  destroy() {
-    this.destroy$.next();
-  }
-
-  state$ = toObservable(this.state);
-  selectRequestState$ = this.state$.pipe(map(s => s.response));
-  selectResponse$: Observable<T> = this.selectRequestState$.pipe(
-    filter(isSuccessState),
-    map( state => state.body)
-  );
-
-  /**
-   * @deprecated use selectRequestState$ instead
-   */
-  selectHttpState$ = this.selectRequestState$;
-  selectStatus$ = this.selectRequestState$.pipe(map(s => s.status));
-  selectError$ = this.selectRequestState$.pipe(
-    filter(isErrorState),
-    map(state => state.error)
-  );
-
-  refresh(){
-    if(this.$isNotStarted()) {
-      throw new Error("Cannot refresh a request that has not been started. Call request() first.");
-    }
-    if(this.$isError()){
-      throw new Error("Cannot refresh a request that is in error state. Call reset() and request() first.");
-    }
-    const params = this.state().requestParams;
-    this.request(...params);
-  }
-}
-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 }>;
-/**
- * @param sigOrObs An array of signals or observables to be wrapped in an array to be spread into the request function.
- * 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');
-
-type SignalOrVal<T> = Signal<T> | T;
-type SignalOrValArr<T extends readonly any[]> = { [K in keyof T]: SignalOrVal<T[K]> };

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

@@ -1,20 +0,0 @@
-/**
- * @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';