@one-paragon/angular-utilities 0.1.21 → 0.1.23

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

@@ -1,70 +0,0 @@
-import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
-import { defaultShareReplay } from '../../rxjs/defaultShareReplay';
-import { isObservable, Observable, Subject, Unsubscribable } from 'rxjs';
-import { map, switchAll } from 'rxjs/operators';
-import { HttpRequestStateStore } from '../HttpRequestStateStore';
-import { HttpRequestState, HttpRequestStatus } from '../types';
-
-export interface HttpRequestStateViewContext<T> {
-    $implicit?: HttpRequestState<T>;
-    state?:  HttpRequestState<T>;
-    status: {
-        inProgress: boolean;
-        notStarted: boolean;
-        success: boolean;
-        error: boolean;
-    };
-}
-
-@Directive({ selector: '[httpRequestState]' })
-export class HttpRequestStateDirective<TParam extends any[],T> {
-
-    readonly ViewContext: HttpRequestStateViewContext<T> = {
-        $implicit: undefined,
-        state: undefined,
-        status: {
-            inProgress: false,
-            notStarted: true,
-            success: false,
-            error: false,
-        }
-      };
-
-
-    subject = new Subject<Observable<HttpRequestState<T>>>();
-    state = this.subject.pipe(switchAll(),defaultShareReplay());
-    subscription: Unsubscribable;
-    hooks: ((state: HttpRequestState<T>) => void) [] = [];
-
-    @Input('httpRequestState') set stateStore(store: HttpRequestStateStore<TParam,T> | Observable<HttpRequestState<T>> ) {
-        if(isObservable(store)) {
-            this.subject.next(store);
-        } else {
-            this.subject.next(store.state$.pipe(map(state => state.response)));
-        }
-
-    }
-    constructor(
-        private templateRef: TemplateRef<any>,
-        private viewContainer: ViewContainerRef,
-    ) {
-        this.viewContainer.createEmbeddedView(this.templateRef, this.ViewContext);
-        this.subscription = this.state.subscribe( state => {
-            this.ViewContext.$implicit = state;
-            this.ViewContext.state = state;
-            this.ViewContext.status.inProgress = state.status === HttpRequestStatus.inProgress;
-            this.ViewContext.status.notStarted = state.status === HttpRequestStatus.notStarted;
-            this.ViewContext.status.success = state.status === HttpRequestStatus.success;
-            this.ViewContext.status.error = state.status === HttpRequestStatus.fail;
-            this.hooks.forEach( hook => hook(state));
-        });
-    }
-
-
-    ngOnDestroy() {
-        this.viewContainer.clear();
-        this.subscription.unsubscribe();
-      }
-
-
-}

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

@@ -1,30 +0,0 @@
-import { HttpRequestState, HttpRequestStateError, HttpRequestStateInProgress, HttpRequestStateNotStarted, HttpRequestStateSuccess, HttpRequestStatus } from "./types";
-
-export function isErrorState<T>(state: HttpRequestState<T>): state is HttpRequestStateError {
-  return state.status === HttpRequestStatus.fail;
-}
-
-export function isSuccessState<T>(state: HttpRequestState<T>): state is HttpRequestStateSuccess<T> {
-  return state.status === HttpRequestStatus.success;
-}
-
-export function isSuccessOrErrorState<T>(state: HttpRequestState<T>): state is (HttpRequestStateSuccess<T> | HttpRequestStateError) {
-  return state.status === HttpRequestStatus.success || state.status === HttpRequestStatus.fail;
-}
-
-export function createSuccess<T>(body: T): HttpRequestStateSuccess<T> {
-  return { status: HttpRequestStatus.success, body };
-}
-
-export function createFailure(error: any): HttpRequestStateError {
-  return { status: HttpRequestStatus.fail, error };
-}
-
-export const notStarted: HttpRequestStateNotStarted = { status: HttpRequestStatus.notStarted };
-
-
-export const inProgress: HttpRequestStateInProgress = { status: HttpRequestStatus.inProgress };
-
-export function statusIsSuccessOrInProgress( status: HttpRequestStatus) {
-  return [HttpRequestStatus.success, HttpRequestStatus.inProgress].includes(status);
-}

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

@@ -1,69 +0,0 @@
-import { map, startWith, switchMap } from 'rxjs/operators';
-import { getRequestorBody } from './rxjs/getRequestorBody';
-import { getRequestorStatus } from './rxjs/getRequestorState';
-import { mapError } from '../rxjs/mapError';
-import { defaultShareReplay } from '../rxjs/defaultShareReplay';
-import { Observable, of, ReplaySubject } from 'rxjs';
-import { HttpRequestFactory, HttpRequestState, HttpRequestStatus } from './types';
-import { createFailure, createSuccess, inProgress, notStarted } from './helpers';
-
-export type HttpRequestState$ <T> = Observable<HttpRequestState<T>>;
-
-export interface HttpRequestor <Res, Req> {
-  httpState$: Observable<HttpRequestState<Res>>;
-  status$: Observable<HttpRequestStatus>;
-  body$: Observable<Res>;
-  request: Req;
-}
-
-export function httpRequest<T = any>(req: Observable<T>): HttpRequestState$<T> {
-  return req.pipe(
-    map(createSuccess),
-    mapError(createFailure),
-    startWith(inProgress),
-    defaultShareReplay()
-  );
-}
-
-export function httpRequestor<TParam extends any[], T>(req: HttpRequestFactory<TParam,T> ): HttpRequestor<T, (...params: [...TParam]) => Observable<HttpRequestState<T>>> {
-  const request$ = new ReplaySubject<[...TParam]>(1);
-  const httpState$ : HttpRequestState$<T> = request$.pipe(
-    switchMap( (params) => httpRequest<T>(req(...params)) ),
-    startWith(notStarted),
-    defaultShareReplay(),
-  );
-  const request = (...params: [...TParam]) => {
-    request$.next(params);
-    return httpState$;
-  };
-  return ({
-    request,
-    httpState$,
-    body$: httpState$.pipe(getRequestorBody),
-    status$: httpState$.pipe(getRequestorStatus)
-  });
-}
-
-export function chainRequest<TParam extends any[], T, TT>(
-  httpState$: Observable<HttpRequestState<T>>,
-  request:HttpRequestFactory<TParam,TT>,
-  requestParams: ((responseFromPrevious: T) => [...TParam]) | (() => [...TParam])
-  ): Observable<HttpRequestState<TT>> {
-  return httpState$.pipe(
-    switchMap( res => {
-      if(res.status === HttpRequestStatus.success) {
-        const secondReq = httpRequestor<[...TParam], TT>(request);
-        const param = requestParams(res.body);
-        secondReq.request(...param );
-        return secondReq.httpState$;
-      } else {
-        return of(res);
-      }
-    }),
-  );
-}
-
-
-
-
-

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

@@ -1,26 +0,0 @@
-import { NgModule } from '@angular/core';
-import { HttpSuccessStateDirective } from './directives/http-success-state-directive';
-import { HttpRequestStateDirective } from './directives/request-state-directive';
-import { HttpErrorStateDirective } from './directives/http-error-state-directive';
-import { HttpInProgressStateDirective } from './directives/http-inProgress-state-directive';
-import { HttpNotStartedStateDirective } from './directives/http-notStarted-state-directive';
-
-@NgModule({
-    providers:[],
-    declarations: [
-        HttpSuccessStateDirective,
-        HttpRequestStateDirective,
-        HttpErrorStateDirective,
-        HttpInProgressStateDirective,
-        HttpNotStartedStateDirective,
-    ],
-    exports: [
-        HttpSuccessStateDirective,
-        HttpRequestStateDirective,
-        HttpErrorStateDirective,
-        HttpInProgressStateDirective,
-        HttpNotStartedStateDirective,
-    ]
-}) export class HttpRequestModule {
-
-}

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/rxjs/getRequestorBody.ts

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

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

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

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

@@ -1,16 +0,0 @@
-import { Observable } from 'rxjs';
-import { tap } from 'rxjs/operators';
-import { HttpRequestState } from '../types';
-import { isErrorState } from '../helpers';
-
-export function tapError(onError: (error: any) => void) {
-  return function (src: Observable<HttpRequestState>): Observable<HttpRequestState> {
-    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 { HttpRequestState } from '../types';
-import { isSuccessState } from '../helpers';
-
-export function tapSuccess<T>(onSuccess: (body: T) => void) {
-  return function (src: Observable<HttpRequestState<T>>): Observable<HttpRequestState<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 { HttpRequestStrategy } from "./types";
-
-describe('HttpRequestStateStore', () => {
-
-    it('should throw when strategy is use once and it was reused',  () =>  {
-        const requestState = new MockHttpRequestState<string>({strategy: HttpRequestStrategy.singleUse});
-        requestState.request();
-        expect( ()=>{
-            requestState.request();
-        } ).toThrow();
-    });
-
-    
-    it('should emit both when strategy is concurrent',  (done) =>  {
-        const requestState = new MockHttpRequestState<string>({strategy: HttpRequestStrategy.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: HttpRequestStrategy.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,50 +0,0 @@
-import { Observable } from 'rxjs';
-export enum HttpRequestStatus {
-    notStarted,
-    inProgress,
-    success,
-    fail,
-    cancelled,
-  }
-
-  export type HttpRequestStateCancelled = {
-    status: HttpRequestStatus.cancelled
-  }
-
-  export type HttpRequestStateNotStarted = {
-    status: HttpRequestStatus.notStarted
-  }
-
-  export type HttpRequestStateInProgress = {
-    status: HttpRequestStatus.inProgress
-  }
-
-  export type HttpRequestStateSuccess<T> = {
-    status: HttpRequestStatus.success;
-    body: T;
-  }
-
-  export type HttpRequestStateError = {
-    status: HttpRequestStatus.fail;
-    error: any;
-  }
-
-
-  export type HttpRequestState<T = any> =
-  HttpRequestStateCancelled |
-    HttpRequestStateNotStarted |
-    HttpRequestStateInProgress |
-    HttpRequestStateSuccess<T> |
-    HttpRequestStateError ;
-
-export enum HttpRequestStrategy {
-  concurrent = 1,
-  singleUse = 2,
-  cancelPrevious = 3,
-  sequential = 4,
-}
-export interface RequestStateOptions {
-  strategy?: HttpRequestStrategy
-}
-
-export type HttpRequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>

package/src/ngrx/actionable-selector.ts

@@ -1,95 +0,0 @@
-import { Action, createSelector, MemoizedSelector, Store } from "@ngrx/store";
-import { v4 as uuid } from 'uuid';
-
-class AppStoreCache {
-  cache: {
-    actionableSelectorId$: string,
-    [key: string]: any;
-  }[] = [];
-  isInCache = (props: any, actionableSelectorId: string): boolean => {
-    if(typeof props != 'object') props = { props };
-    const valueToCache = { ...props, actionableSelectorId$: actionableSelectorId };
-    if(this.cache.some(item => shallowEquals(item, valueToCache))) {
-      return true;
-    }
-    this.cache.push(valueToCache);
-    return false;
-  }
-}
-
-let _store: Store<any>;
-let _cache = new AppStoreCache();
-
-const setStore = (store: Store) => {
-  if(store instanceof Store) _store = store;
-};
-export function setUpStoreFactory(store: Store){
-  return () => new Promise((resolve, reject) => {
-    setStore(store);
-    resolve(null);
-  })
-}
-
-/**
- * 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 selector.
- * @param action The action that will be dispatched when conditions are met.
- * @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 = any>(
-  selectorFactory: (props?: Props) => MemoizedSelector<State, Result>,
-  action: ActionReturner<Props | undefined>,
-  dispatchIf: (data: Result) => boolean = defaultFilter,
-): (props?: Props) => ActionableMemoizedSelector<State, Result> => {
-  const id = uuid();
-  const slctr = (props?: Props) => createSelector(
-    selectorFactory(props),
-    (selected: Result) => {
-      if(dispatchIf(selected) && !_cache.isInCache(props, id)){
-        //Adding the null check for testing purposes. Otherwise it should never be null.
-        _store.dispatch(action(props));
-      }
-      return selected;
-    }
-  ) as ActionableMemoizedSelector<State, Result>;
-  return slctr;
-}
-
-type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
-
-export type ActionReturner<Props> = (props: Props) => Action;
-
-export function defaultFilter(data: any) {
-  return data == null || data == undefined;
-}
-
-
-
-
-/**
- * Returns a shallow clone without prop. Will not error if prop does not exist.
- * @param prop name of property to be removed.
- * @returns a shallow clone without prop
- */
- const deleteProp = <T extends {}, Prop extends string>(t: T, prop: keyof T & Prop): Omit<T, Prop> => {
-  const copy = { ...t };
-  delete copy[prop];
-  return copy;
-}
-
-const shallowEquals = (first: object, second: object): boolean => {
-  const firstKeys = Object.keys(first);
-  const secondKeys = Object.keys(second);
-  if(firstKeys.length !== secondKeys.length) {
-    return false;
-  }
-  for(let index = 0; index < firstKeys.length; index++) {
-    const currentKey = firstKeys[index];
-    if(first[currentKey] !== second[currentKey]){
-      return false;
-    }
-  }
-  return true;
-}

package/src/ngrx/index.ts

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

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/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 { flatten } from 'lodash';
-import {
-  filter,
-  first,
-  map,
-  pairwise,
-  startWith,
-  Observable,
-  combineLatest,
-  Subscription,
-  MonoTypeOperatorFunction,
-  OperatorFunction,
-  concatMap,
-  merge,
-  of,
-  delay
-} 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) => 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 function onWait<T,V extends T>(val: V) : MonoTypeOperatorFunction<T> {
-  return (source: Observable<T>) => {
-    return new Observable<T>(subscriber => {
-      let emitted = false;
-      setTimeout(() => {
-        if(!emitted) {
-          subscriber.next(val);
-        }
-      }, 0);
-      source.subscribe({
-        next(x) { emitted = true; subscriber.next(x) },
-        error(err) { emitted = true; subscriber.error(err) },
-        complete() { emitted = true; subscriber.complete(); }
-      });
-    });
-  }
-
-}
-
-export const combineArrays = <T>(sources: Observable<T[]>[]): Observable<T[]> => {
-  return combineLatest(
-    sources.map( src => src.pipe(onWait([])))
-  ).pipe(
-    map( res => flatten(res) )
-  );
-};
-
-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>(): OperatorFunction<(T | null | undefined), T> {
-  return  (source: Observable<T | null | undefined>) => {
-    return  source.pipe(filter( (o: T | null | undefined): o is 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,15 +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 = merge(this._source, this._subj);
-  constructor(private _source: Observable<T>){
-    super((obs: Observer<T>) => {
-      const s = merge( _source, this._subj ).subscribe(obs);
-      return s;
-    });
-  }
-  next: Subject<T>['next'] = this._subj.next.bind(this._subj);
-  newSubj = (...operations: Parameters<PipeLike<T>>) =>
-    new Subjectifier(this.merged.pipe(...operations));
-}