@one-paragon/angular-utilities 2.8.4 → 2.8.6

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

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

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

@@ -1,66 +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 { RequestFactory, RequestState, RequestStatus } from './types';
-import { createFailure, createSuccess, inProgress, notStarted } from './helpers';
-
-export type HttpRequestState$ <T> = Observable<RequestState<T>>;
-
-export interface HttpRequestor <Res, Req> {
-  httpState$: Observable<RequestState<Res>>;
-  status$: Observable<RequestStatus>;
-  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: RequestFactory<TParam, T> ): HttpRequestor<T, (...params: [...TParam]) => Observable<RequestState<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<RequestState<T>>,
-  request:RequestFactory<TParam, TT>,
-  requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])
-): Observable<RequestState<TT>> {
-  return httpState$.pipe(
-    switchMap( res => {
-      if(res.status === RequestStatus.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/rxjs/getRequestorBody.ts

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

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

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

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

@@ -1,4 +0,0 @@
-export * from './getRequestorBody';
-export * from './getRequestorState';
-export * from './tapError';
-export * from './tapSuccess';

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

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

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

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

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

@@ -1,42 +0,0 @@
-import { toArray } from "rxjs/operators";
-import { MockHttpRequestState } from "./directives/request-state-directive.spec";
-import { RequestStrategy } from "./types";
-
-describe('HttpRequestStateStore', () => {
-
-  it('should throw when strategy is use once and it was reused', () => {
-    const requestState = new MockHttpRequestState<string>({ strategy: RequestStrategy.singleUse });
-    requestState.request();
-    expect( () => {
-      requestState.request();
-    } ).toThrow();
-  });
-
-
-  it('should emit both when strategy is concurrent', (done) => {
-    const requestState = new MockHttpRequestState<string>({ strategy: RequestStrategy.concurrent });
-    requestState.request();
-    requestState.request();
-    requestState.selectResponse$.pipe( toArray()
-    ).subscribe( d => {
-      expect(d.length).toBe(2);
-      done();
-    });
-    requestState.subject.next('hi');
-    requestState.ngOnDestroy();
-  });
-
-  it('should emit only one when strategy is cancel previous', (done) => {
-    const requestState = new MockHttpRequestState<string>({ strategy: RequestStrategy.cancelPrevious });
-    requestState.request();
-    requestState.request();
-    requestState.selectResponse$.pipe( toArray()
-    ).subscribe( d => {
-      expect(d.length).toBe(1);
-      done();
-    });
-    requestState.subject.next('hi');
-    requestState.ngOnDestroy();
-
-  });
-});

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

@@ -1,54 +0,0 @@
-import { Injector } from '@angular/core';
-import { Observable } from 'rxjs';
-export enum RequestStatus {
-    notStarted,
-    inProgress,
-    success,
-    fail,
-    cancelled,
-  }
-
-export type RequestStateCancelled = {
-    status: RequestStatus.cancelled
-  }
-
-export type RequestStateNotStarted = {
-    status: RequestStatus.notStarted
-  }
-
-export type RequestStateInProgress = {
-    status: RequestStatus.inProgress
-  }
-
-export type RequestStateSuccess<T> = {
-    status: RequestStatus.success;
-    body: T;
-  }
-
-export type RequestStateError = {
-    status: RequestStatus.fail;
-    error: any;
-  }
-
-
-export type RequestState<T = any> =
-    RequestStateCancelled |
-    RequestStateNotStarted |
-    RequestStateInProgress |
-    RequestStateSuccess<T> |
-    RequestStateError ;
-
-export enum RequestStrategy {
-  concurrent = 1,
-  singleUse = 2,
-  cancelPrevious = 3,
-  sequential = 4,
-}
-export interface RequestStateOptions<TParam extends any[] = any> {
-  strategy?: RequestStrategy;
-  autoRequest?: TParam extends never[] ? true : never;
-}
-
-export interface RequestCreatorOptions<TParam extends any[] = any> extends RequestStateOptions<TParam> { injector?: Injector }
-
-export type RequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>

package/src/ngrx/actionable-selector.ts

@@ -1,189 +0,0 @@
-import { EnvironmentInjector, inject, Injector, makeEnvironmentProviders, provideAppInitializer, runInInjectionContext } from "@angular/core";
-import { Action, createSelector, MemoizedSelector, Store } from "@ngrx/store";
-
-let _store: Store<any>;
-let _cache: AppStoreCache;
-let _ei : EnvironmentInjector;
-
-/**
- * Creates a selector that can dispatch an action if conditions are met.
- * Note: The props of the selector factory must include the props of the action.
- * @param selectorFactory A method that returns a selector.
- * @param action A method that returns the action that will be dispatched when conditions are met. The method will be passed the args of the
- * selector factory and the result of the selector.
- * @param [dispatchIf = defaultFilter] Optional. A method that takes the result of the selector and returns a boolean. The actions gets dispatched
- * if true is returned. If no method is passed in than the action will be dispatched if the selector returns undefined or null.
- */
-export const createActionableSelector = <State, Result, Props extends any[]>(
-  selectorFactory: ((...props: Props) => MemoizedSelector<State, Result>),
-  action: ActionReturner<Props, Result>,
-  dispatchIf: (data: Result) => boolean = defaultFilter,
-  defaultValue?: Result
-) => {
-  const options = {
-    selectorFactory,
-    action: (...props: [...Props, Result]) => () => _store.dispatch(action(...props)),
-    dispatchIf,
-    defaultValue
-  }
-  const actionable = createActionResultSelector(options);
-  return (...props: Props) => createSelector(actionable(...props), b => b.result);
-}
-
-/**
- * Creates a selector that can run an action if conditions are met.
- * The action will run in the environment injector context if no injector is added to the options
- * Note: The props of the selector factory must include the props of the action.
- */
-export const createActionSelector = <State, Result, Props extends any[] = any[]>(options: CreateActionResultsOptions<State, Result, Props>) => {
-  const actionable = createActionResultSelector(options);
-  return ((...props: [...Props]) => createSelector(actionable(...props), b => b.result));
-}
-
-export const createActionableResultSelector = <State, Result, Props extends any[]>(
-  selectorFactory: ((...props: Props) => MemoizedSelector<State, Result>),
-  action: ActionReturner<Props, Result>,
-  dispatchIf: (data: Result) => boolean = defaultFilter,
-  defaultValue?: Result
-) => {
-  const options: CreateActionResultsOptions<State, Result, Props> = {
-    selectorFactory,
-    action: (...props: [...Props, Result]) => () => _store.dispatch(action(...props)),
-    dispatchIf,
-    defaultValue
-  };
-
-  return createActionResultSelector(options);
-}
-
-export const createActionResultSelector = <State, Result, Props extends any[] = any[]>(options: CreateActionResultsOptions<State, Result, Props>) => {
-  const id = crypto.randomUUID();
-  const dispatchCheck = options.dispatchIf || defaultFilter;
-  const slctr = (...props: Props) => createSelector(
-    options.selectorFactory(...props),
-    (selected: Result) => {
-      const needsDispatch = dispatchCheck(selected);
-      if(needsDispatch && !_cache.isInCache(id, ...props)){
-        queueMicrotask(() =>
-          runInInjectionContext(options.injector || _ei, () => {
-            options.action(...[...props, selected])()
-          }));
-      }
-      return ({
-        loading: needsDispatch,
-        result: needsDispatch && options.defaultValue !== undefined ? options.defaultValue : selected
-      });
-    }
-  ) as ActionableMemoizedSelector<State, LoadingState<Result>>;
-  return slctr;
-}
-
-class AppStoreCache {
-  cache: Cache = {};
-  isInCache = (actionableSelectorId: string, ...p: any[]): boolean => {
-    const props = p.reduce((a, b) => {
-      if(typeof b != 'object') b = { b };
-      return ({ ...a, ...b })
-    }, {});
-
-    const itemsInCache = this.cache[actionableSelectorId] = (this.cache[actionableSelectorId] || []);
-
-    if(itemsInCache.some(itemInCache => shallowEquals(itemInCache, props))){
-      return true;
-    }
-
-    itemsInCache.push(props);
-    return false;
-  }
-}
-
-export const clearActionableSelectorRequestCache = () => _cache.cache = {};
-
-const shallowEquals = (cachedItem: object, newItem: object): boolean => {
-  const cachedItemKeys = Object.keys(cachedItem);
-  const secondKeys = Object.keys(newItem);
-  if(cachedItemKeys.length !== secondKeys.length) {
-    return false;
-  }
-  for(let index = 0; index < cachedItemKeys.length; index++) {
-    const currentKey = cachedItemKeys[index];
-    if(cachedItem[currentKey] !== newItem[currentKey]){
-      return false;
-    }
-  }
-  return true;
-}
-
-export function defaultFilter(data: any) {
-  return data == null || data == undefined;
-}
-
-const setStore = (store: Store) => {
-  if(store instanceof Store) _store ??= store;
-};
-
-const setEnvironmentInjector = (ei: EnvironmentInjector) => {
-  if(ei instanceof EnvironmentInjector) _ei ??= ei;
-};
-
-export function provideActionableSelector(){
-  return makeEnvironmentProviders([
-    provideAppInitializer(setUpStoreFactory)
-  ])
-}
-
-export const setUpStoreFactory = () => {
-  const store = inject(Store);
-  const env = inject(EnvironmentInjector);
-  _cache ??= new AppStoreCache();
-  setStore(store);
-  setEnvironmentInjector(env)
-}
-
-export function setUpStoreFactoryOld(store: Store, env: EnvironmentInjector){
-  _cache ??= new AppStoreCache();
-  return () => new Promise((resolve, reject) => {
-    setStore(store);
-    setEnvironmentInjector(env)
-    resolve(null);
-  })
-}
-
-export interface CreateActionResultsOptions<State, Result, Props extends any[]>{
-  /**
-   * A method that returns a selector.
-   */
-  selectorFactory: (...props: Props) => MemoizedSelector<State, Result>,
-  /**
-   * The action to run when conditions are met.
-   * The method will be passed the args of the selector factory and the result of the selector.
-   * @param props args of the selector factory and the result of the selector.
-   */
-  action: (...props: [...Props, Result]) => () => void,
-  /**
-   * Optional. A method that takes the result of the selector and returns a boolean. The actions gets dispatched
-   * if true is returned. If no method is passed in than the action will be dispatched if the selector returns undefined or null.
-   * @param data The result of the selector.
-   * @returns boolean
-   */
-  dispatchIf?: (data: Result) => boolean,
-  injector?: Injector,
-
-  /**
-   * The default value to use if the selector returns undefined or null.
-   */
-  defaultValue?: Result
-}
-
-interface LoadingState<T> {
-  loading: boolean;
-  result?: T;
-}
-
-type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
-
-export type ActionReturner<Props extends any[], Result = any> = (...props: [...Props, Result]) => Action;
-
-type Cache = {
-  [key: string]: { [key: string]: any }[];
-}

package/src/ngrx/index.ts

@@ -1 +0,0 @@
-export * from './actionable-selector';

package/src/public-api.ts

@@ -1,40 +0,0 @@
-/*
- * Public API Surface of http-request-state
- */
-
-export * from './http-request-state/directives';
-export * from './http-request-state/rxjs';
-export * from './http-request-state';
-
-
-export * from './table-builder/table-builder.module';
-
-export * from './table-builder/classes/TableBuilderConfig';
-
-export * from './table-builder/interfaces/meta-data';
-
-export * from './table-builder/classes/MatTableObservableDataSource';
-
-export * from './table-builder/classes/table-builder';
-
-export * from './table-builder/classes/table-builder-general-settings';
-export * from './table-builder/classes/filter-info';
-export * from './table-builder/types/group-types';
-
-export * from './table-builder/components';
-
-export * from './table-builder/components/table-container/table-container.helpers/groupBy.helpers';
-
-export * from './table-builder/directives';
-
-export * from './table-builder/enums/filterTypes';
-
-
-export * from './rxjs'
-
-export * from './utilities'
-
-export * from './action-state';
-
-export * from './ngrx';
-

package/src/rxjs/defaultShareReplay.ts

@@ -1,8 +0,0 @@
-import { Observable } from 'rxjs';
-import { shareReplay } from 'rxjs/operators';
-
-export function defaultShareReplay<T>() {
-  return function (src: Observable<T>): Observable<T> {
-    return src.pipe(shareReplay({ refCount: true, bufferSize: 1 }));
-  };
-}

package/src/rxjs/index.ts

@@ -1,5 +0,0 @@
-export * from './defaultShareReplay'
-export * from './mapError';
-export * from './rxjs-operators';
-export * from './subjectifier';
-export * from './subscriber.directive';

package/src/rxjs/mapError.ts

@@ -1,8 +0,0 @@
-import { Observable, of } from 'rxjs';
-import { catchError } from 'rxjs/operators';
-
-export function mapError<T, TResult>(projection: (error: any) => TResult) {
-  return function (src: Observable<T>): Observable<T | TResult> {
-    return src.pipe(catchError(e => of(projection(e))),);
-  };
-}

package/src/rxjs/rxjs-operators.ts

@@ -1,130 +0,0 @@
-import { Predicate } from '@angular/core';
-import {
-  filter,
-  first,
-  map,
-  pairwise,
-  startWith,
-  Observable,
-  combineLatest,
-  Subscription,
-  MonoTypeOperatorFunction,
-  OperatorFunction,
-  concatMap,
-  merge,
-  of,
-  delay,
-  pipe
-} from 'rxjs';
-
-
-export const onceWhen = <T>(predicate: Predicate<T>) => (src: Observable<T>) : Observable<T> => {
-  return src.pipe(filter(predicate), first());
-}
-
-export const mapArray = <T, U>(mapFunc: (src: T, index?: number) => U ) => (source: Observable<T[]>) =>
-  source.pipe( map( src => src.map(mapFunc) ) );
-
-export const filterArray = <T>(filterFunc: (src: T) => boolean ) => (source: Observable<T[]>) =>
-  source.pipe( map( src => src.filter(filterFunc) ) );
-
-export const onWait = startWithIfEmpty;
-export function startWithIfEmpty<T, V extends T>(val: V, wait = 0) : MonoTypeOperatorFunction<T> {
-  return (source: Observable<T>) => {
-    return new Observable<T>(subscriber => {
-      let emitted = false;
-      setTimeout(() => {
-        if(!emitted) {
-          subscriber.next(val);
-        }
-      }, wait);
-      const sub = source.subscribe({
-        next(x) { emitted = true; subscriber.next(x) },
-        error(err) { emitted = true; subscriber.error(err) },
-        complete() { emitted = true; subscriber.complete(); }
-      });
-      return () => sub.unsubscribe();
-    });
-  }
-
-}
-
-export const combineArrays = <T>(sources: Observable<T[]>[]): Observable<T[]> => {
-  return combineLatest(
-    sources.map( src => src.pipe(startWithIfEmpty([] as T [])))
-  ).pipe(
-    map( res => res.flat() )
-  );
-};
-
-export function switchOff( switchSource: Observable<boolean>, defaultState: boolean = true) {
-  return <T>(source: Observable<T>) : Observable<T> => {
-    return new Observable(subsciber => {
-      let isOn = defaultState;
-      const subscription = new Subscription();
-      subscription.add( switchSource.subscribe( on => isOn = on ));
-      subscription.add(source.subscribe({
-        next(value) {
-          if(isOn) {
-            subsciber.next(value);
-          }
-        },
-        error: error => subsciber.error(error),
-        complete: () => subsciber.complete()
-      }));
-      return subscription;
-    });
-  }
-}
-
-export function skipOneWhen( skipper: Observable<any> ) {
-  return <T>(source: Observable<T>) : Observable<T> => {
-    return new Observable(subsriber => {
-      const subscription = new Subscription();
-      let skipNext = false;
-      subscription.add(skipper.subscribe( _ => skipNext = true));
-      subscription.add(source.subscribe({
-        next(value) {
-          if(skipNext) {
-            skipNext = false;
-          } else {
-            subsriber.next(value);
-          }
-        },
-        error: error => subsriber.error(error),
-        complete: () => subsriber.complete()
-      }));
-      return subscription;
-    });
-  }
-}
-
-export function previousAndCurrent<T>(startingValue : T) : OperatorFunction<T, [T, T]> {
-  return (source: Observable<T>) => {
-    return source.pipe(startWith(startingValue), pairwise());
-  }
-}
-
-export function notNull<T>() {
-  return pipe(filter<T, NonNullable<T>>((o): o is NonNullable<T> => o != null))
-}
-
-export function delayOn<T>(predicate: (t: T) => boolean, delayTime: number) {
-  return (src: Observable<T>) => {
-    return src.pipe(
-      concatMap(r => {
-        if(predicate(r)) {
-          return merge(
-            of({ r }),
-            of(null).pipe(delay(delayTime))
-          ).pipe(
-            notNull(),
-            map(d => d.r)
-          );
-        } else {
-          return of(r);
-        }
-      })
-    );
-  };
-}

package/src/rxjs/subjectifier.ts

@@ -1,17 +0,0 @@
-import { merge, Observable, Observer, Subject } from 'rxjs';
-type PipeLike<T> = Observable<T>['pipe'];
-export class Subjectifier<T> extends Observable<T>{
-  private _subj = new Subject<T>();
-  private merged: Observable<T>;
-  constructor(_source: Observable<T>){
-    super((obs: Observer<T>) => {
-      const s = merge( _source, this._subj ).subscribe(obs);
-      return s;
-    });
-
-    this.merged = merge(_source, this._subj);
-  }
-  next: Subject<T>['next'] = this._subj.next.bind(this._subj);
-  newSubj = (...operations: Parameters<PipeLike<T>>) =>
-    new Subjectifier(this.merged.pipe(...operations));
-}