@one-paragon/angular-utilities 1.2.18 → 1.3.1

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,55 +0,0 @@
-import { Injector } from '@angular/core';
-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<TParam extends any[] = any> {
-  strategy?: HttpRequestStrategy;
-  autoRequestWith?: [...TParam];
-  injector?: Injector;
-}
-
-export interface RequestCreatorOptions<TParam extends any[] = any> extends RequestStateOptions<TParam> {}
-
-export type HttpRequestFactory<TParam extends any[], T> = (...params: [...TParam]) => Observable<T>

package/src/ngrx/actionable-selector.ts

@@ -1,152 +0,0 @@
-import { APP_INITIALIZER, EnvironmentInjector, Injector, makeEnvironmentProviders, runInInjectionContext, untracked } from "@angular/core";
-import { Action, createSelector, MemoizedSelector, Store } from "@ngrx/store";
-import { v4 as uuid } from 'uuid';
-
-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 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 extends any[]>(
-  selectorFactory: ((...props: Props) => MemoizedSelector<State, Result>),
-  action: ActionReturner<Props>,
-  dispatchIf: (data: Result) => boolean = defaultFilter,
-) => {
-  const options = {
-    selectorFactory,
-    action: (...props: Props) => () => _store.dispatch(action(...props)),
-    dispatchIf
-  }
-  const actionable = createActionResultSelector(options);
-  return (...props: Props) => createSelector(actionable(...props), b => b.result);
-}
-
-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>,
-  dispatchIf: (data: Result) => boolean = defaultFilter,
-) => {
-  const options: CreateActionResultsOptions<State, Result, Props> = { 
-    selectorFactory,
-    action: (...props: Props) => () => _store.dispatch(action(...props)),
-    dispatchIf
-  };
-
-  return createActionResultSelector(options);
-}
-
-export const createActionResultSelector = <State, Result, Props extends any[] = any[]>(options: CreateActionResultsOptions<State, Result, Props>) => {
-  const id = uuid();
-  const slctr = (...props: Props) => createSelector(
-    options.selectorFactory(...props),
-    (selected: Result) => {
-      const needsDispatch = (options.dispatchIf || defaultFilter)(selected);
-      if(needsDispatch && !_cache.isInCache(id, ...props)){
-        queueMicrotask(() =>  
-          runInInjectionContext(options.injector || _ei, () => {
-            options.action(...props)()
-          }));
-      }
-      return ({
-        loading: needsDispatch,
-        result: 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 })
-    }, {});
-
-    let 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([
-    { provide: APP_INITIALIZER, useFactory: setUpStoreFactory, multi: true, deps: [Store, EnvironmentInjector] },
-  ])
-}
-
-export function setUpStoreFactory(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[]>{
-  selectorFactory: (...props: Props) => MemoizedSelector<State, Result>,
-  action: (...props: Props) => () => void,
-  dispatchIf?: (data: Result) => boolean,
-  injector?: Injector
-}
-
-interface LoadingState<T> {
-  loading: boolean;
-  result?: T;
-}
-
-type ActionableMemoizedSelector<State, Result> = MemoizedSelector<State, Result>;
-
-export type ActionReturner<Props extends any[]> = (...props: Props) => Action;
-
-type Cache = {
-  [key: string]: { [key: string]: any }[];
-}

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,132 +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, 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>(): 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,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));
-}

package/src/rxjs/subscriber.directive.ts

@@ -1,57 +0,0 @@
-import { DestroyRef, Directive, Injector, OnDestroy, assertInInjectionContext, inject } from "@angular/core";
-import { Observable, Subscription } from "rxjs";
-
-@Directive()
-export class Subscriber implements OnDestroy{
-  subscriptions: Subscription[] = [];
-  handle = (subscription: Subscription) => {
-    this.subscriptions.push(subscription);
-  }
-  on = <T = any>(obs: Observable<T>, action: (t: T) => any) => {
-    this.handle(obs.subscribe(action));
-  }
-
-  ngOnDestroy() {
-    this.subscriptions.forEach(subscription => {
-      subscription.unsubscribe();
-    });
-  }
-}
-
-export function subscriber(injector: Injector): Subscriber
-export function subscriber(subscription?: Subscription, injector?: Injector): Subscriber
-export function subscriber<T = any>(obs: Observable<T>, action: (t: T) => any, injector?: Injector): Subscriber
-export function subscriber<T = any>(obsOrSubOrInjector?: Observable<T> | Subscription | Injector, actionOrInjector?: ((t: T) => any) | Injector, injector?: Injector): Subscriber {
-
-  const destroyRef = getDestroyRef(obsOrSubOrInjector, actionOrInjector, injector);
-
-  const subscriber = new Subscriber();
-
-  if(obsOrSubOrInjector instanceof Subscription){
-    subscriber.handle(obsOrSubOrInjector);
-  } else if(obsOrSubOrInjector instanceof Observable){
-    subscriber.handle(obsOrSubOrInjector.subscribe(actionOrInjector as (t: T) => any));
-  }
-
-  destroyRef.onDestroy(() => subscriber?.ngOnDestroy());
-
-  return subscriber;
-}
-
-function getDestroyRef(obsOrSubOrInjector: any, actionOrInjector?: any, injector?: Injector){
-  const providedInjector = obsOrSubOrInjector instanceof Injector ? obsOrSubOrInjector
-    : actionOrInjector instanceof Injector ? actionOrInjector
-    : injector;
-
-  if(!providedInjector){
-    try {
-      assertInInjectionContext(subscriber);
-    } catch (error) {
-      throw new Error('createRequestor() must be used in an Injection Context or you must provide an injector to createRequestor()');
-    }
-  }
-
-  const destroyRef = providedInjector?.get(DestroyRef) || inject(DestroyRef);
-
-  return destroyRef;
-}

package/src/specs/clickSubject.spec.ts

@@ -1,95 +0,0 @@
-import { Component } from "@angular/core";
-import { ComponentFixture, fakeAsync, TestBed, waitForAsync } from "@angular/core/testing";
-import { Subject } from "rxjs";
-import { ClickEmitterDirective, ClickSubjectDirective } from "../utilities";
-import {TestbedHarnessEnvironment} from '@angular/cdk/testing/testbed';
-import {HarnessLoader} from '@angular/cdk/testing';
-import { MatButtonModule } from "@angular/material/button";
-import { MatButtonHarness } from "@angular/material/button/testing";
-
-@Component({
-    template: `
-     <a mat-button clickEmitter  #subj='clickEmitter' >click me</a>
-     <div *ngIf='subj | async'>Hello World!</div>
-    `
-}) export class TestComponent {
-  subject = new Subject();
-}
-
-@Component({
-  template: `
-   <a mat-button [clickSubject]='{content: "Hello World!" }' #subj='clickSubject' >click me</a>
-   <div *ngIf='subj | async as o'>{{o.content}}</div>
-  `
-}) export class TestContentComponent {
-subject = new Subject();
-}
-
-
-let fixture: ComponentFixture<TestComponent>;
-let loader: HarnessLoader;
-
-const setupTest = (): void => {
-  TestBed.configureTestingModule({
-      imports: [MatButtonModule],
-      declarations: [
-        TestComponent,
-        ClickEmitterDirective,
-    ],
-    providers: [  ]
-    });
-    fixture = TestBed.createComponent(TestComponent);
-    fixture.detectChanges();
-    loader = TestbedHarnessEnvironment.documentRootLoader(fixture);
-};
-
-const setupContentTest = (): void => {
-  TestBed.configureTestingModule({
-      imports: [MatButtonModule],
-      declarations: [
-        TestContentComponent,
-        ClickSubjectDirective,
-    ],
-    providers: [  ]
-    });
-    fixture = TestBed.createComponent(TestContentComponent);
-    fixture.detectChanges();
-    loader = TestbedHarnessEnvironment.documentRootLoader(fixture);
-};
-
-
-describe("ClickSubjectDirective", () => {
-  describe("Default Subject", () => {
-    beforeEach(waitForAsync(setupTest));
-
-    it('before button is clicked the text should remain hidden',async () => {
-      expect(fixture.nativeElement.textContent).not.toContain('Hello World!');
-    });
-
-    it('when button is clicked the text should display', fakeAsync( async () => {
-      const buttonHarness = await loader.getHarness(MatButtonHarness);
-      await buttonHarness.click();
-      fixture.detectChanges();
-      expect(fixture.nativeElement.textContent).toContain('Hello World!');
-    }));
-
-  });
-
-  describe("Subject with Content", () => {
-    beforeEach(waitForAsync(setupContentTest));
-
-    it('before button is clicked the text should remain hidden',async () => {
-      expect(fixture.nativeElement.textContent).not.toContain('Hello World!');
-    });
-
-    it('when button is clicked the text should display', fakeAsync( async () => {
-      const buttonHarness = await loader.getHarness(MatButtonHarness);
-      await buttonHarness.click();
-      fixture.detectChanges();
-      expect(fixture.nativeElement.textContent).toContain('Hello World!');
-    }));
-  })
-
-});
-
-