@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

package/src/lib/common/data/field-comparator.ts

@@ -1,122 +0,0 @@
-
-export type ComparatorFn<T> = (a: T, b: T) => number;
-
-export function naturalValueComparator(a: any, b: any): number {
-    return (a < b) ? -1 : (a > b) ? 1 : 0;
-}
-
-export function alphaNumStringComparator(a: any, b: any): number {
-  if (a === b) {
-    return 0;
-  }
-  if (a === null || a === undefined) {
-    return -1;
-  }
-  if (b === null || b === undefined) {
-    return 1;
-  }
-  return a.localeCompare(b, 'en', { numeric: true });
-}
-
-/**
- * Provides the ability to build a sorting comparator dynamically using
- * a given array of fields / additional syntax.
- *
- * - Supports ASC / DESC
- * - Supports multiple fields
- * - Supports nested fields
- *
- * Example:
- *
- * ComparatorBuilder.fieldSort('simple', '-reveresed', 'some.very.deep.nested.path')
- *
- */
-export class ComparatorBuilder {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  public static NATURAL_VALUE_COMPARATOR: ComparatorFn<any> = naturalValueComparator;
-  public static ALPHANUM_STRING_COMPARATOR: ComparatorFn<string> = alphaNumStringComparator;
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Dynamically builds a comparator function, using the given fields for sorting.
-   *
-   * @param fields One or more field name to sort.
-   */
-  public static fieldSort<T = any>(...fields: string[]): ComparatorFn<T> {
-    const props = fields;
-    return function (obj1, obj2) {
-      let i = 0;
-      let result = 0;
-      const numberOfProperties = props.length;
-      /* try getting a different result from 0 (equal)
-       * as long as we have extra properties to compare
-       */
-      while (result === 0 && i < numberOfProperties) {
-        result = ComparatorBuilder.dynamicSort(
-          props[i],
-          ComparatorBuilder.NATURAL_VALUE_COMPARATOR,
-          ComparatorBuilder.ALPHANUM_STRING_COMPARATOR
-        )(obj1, obj2);
-        i++;
-      }
-      return result;
-    };
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-
-  private static dynamicSort<T = any>(
-    property: string,
-    genericValueComparator: ComparatorFn<T>,
-    stringValueComparator: ComparatorFn<string>,
-  ): ComparatorFn<T> {
-    let sortOrder = 1;
-    if (property[0] === '-') {
-      sortOrder = -1;
-      property = property.substr(1);
-    }
-
-    return (a, b) => {
-      const aValue = ComparatorBuilder.resolveProperty(a, property);
-      const bValue = ComparatorBuilder.resolveProperty(b, property);
-      let result: number;
-      if (typeof aValue === 'string' && typeof bValue === 'string') {
-        result = stringValueComparator(aValue, bValue);
-      } else {
-        result = genericValueComparator(aValue, bValue);
-      }
-      return result * sortOrder;
-    };
-  }
-
-
-  private static resolveProperty(obj: any, property: string): any {
-    const parts = property.split('.');
-    let resolved: any = obj;
-
-    for (const part of parts) {
-      if (!resolved) {
-        return null;
-      }
-      resolved = resolved[part];
-    }
-    return resolved;
-  }
-
-}

package/src/lib/common/data/filters/filter-context.spec.ts

@@ -1,150 +0,0 @@
-import {Filter} from './filter';
-import {FilterContext} from './filter-context';
-
-describe('FilterContextTest', () => {
-
-  beforeEach(async () => {
-  });
-
-  beforeEach(() => {
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test replaceFilters                                                     *
-   *                                                                         *
-   **************************************************************************/
-
-  it('FilterContext.replaceFilters', () => {
-    const context = new FilterContext();
-
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-      new Filter('key-b', 'b'),
-      new Filter('key-c', 'c'),
-    ]);
-
-    context.replaceFilters([
-      new Filter('key-a', 'a2'),
-      new Filter('key-b', 'b2')
-    ]);
-
-    expect(context.filtersSnapshot.length).toEqual(2);
-    expect(context.findFilter('key-a').value).toEqual('a2');
-    expect(context.findFilter('key-b').value).toEqual('b2');
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test updateFilters                                                      *
-   *                                                                         *
-   **************************************************************************/
-
-  it('FilterContext.updateFilters', () => {
-    const context = new FilterContext();
-
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-      new Filter('key-b', 'b'),
-      new Filter('key-c', 'c'),
-    ]);
-
-    context.updateFilters([
-      new Filter('key-a', 'a2'),
-      new Filter('key-b', 'b2')
-    ]);
-
-    expect(context.filtersSnapshot.length).toEqual(3);
-    expect(context.findFilter('key-a').value).toEqual('a2');
-    expect(context.findFilter('key-b').value).toEqual('b2');
-    expect(context.findFilter('key-c').value).toEqual('c');
-
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test filter observable                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  it('FilterContext.filter observable distinct', () => {
-    const context = new FilterContext();
-
-    let calmCounter = 0;
-
-    context.filters.subscribe(
-      filters => ++calmCounter
-    );
-
-    expect(calmCounter).toEqual(1);
-
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-      new Filter('key-b', 'b'),
-      new Filter('key-c', 'c'),
-    ]);
-
-    expect(calmCounter).toEqual(2);
-
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-      new Filter('key-b', 'b'),
-      new Filter('key-c', 'c'),
-    ]);
-
-    expect(calmCounter).toEqual(2);
-
-    context.updateFilter(new Filter('key-a', 'a'));
-
-    expect(calmCounter).toEqual(2);
-
-    context.updateFilter(new Filter('key-a', '6'));
-
-    expect(calmCounter).toEqual(3);
-
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test merge filters                                                      *
-   *                                                                         *
-   **************************************************************************/
-
-  it('FilterContext.merge - replace single value', () => {
-    const context = new FilterContext();
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-    ]);
-    context.mergeFilter(new Filter('key-a', 'new'));
-    expect(context.findFilter('key-a').value).toEqual('new');
-  });
-
-  it('FilterContext.merge - append single value', () => {
-    const context = new FilterContext();
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-    ]);
-    context.mergeFilter(new Filter('key-a', ['new']));
-    expect(context.findFilter('key-a').value).toEqual(['a', 'new']);
-  });
-
-  it('FilterContext.merge', () => {
-    const context = new FilterContext();
-    context.replaceFilters([
-      new Filter('key-a', 'a'),
-      new Filter('key-b', ['x', 'y', 'z']),
-      new Filter('key-c', ['c']),
-    ]);
-
-    context.mergeFilter(new Filter('key-a', ['a']));
-    context.mergeFilter(new Filter('key-b', 'q'));
-    context.mergeFilter(new Filter('key-c', 'c'));
-
-    expect(context.findFilter('key-a').value).toEqual(['a']);
-    expect(context.findFilter('key-b').value).toEqual(['x', 'y', 'z', 'q']);
-    expect(context.findFilter('key-c').value).toEqual(['c']);
-
-
-  });
-
-});

package/src/lib/common/data/filters/filter-context.ts

@@ -1,163 +0,0 @@
-import {Filter} from './filter';
-import {BehaviorSubject, Observable} from 'rxjs';
-import {distinctUntilChanged} from 'rxjs/operators';
-
-export class FilterContext {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private readonly _filters$ = new BehaviorSubject<Filter[]>([]);
-
-  /***************************************************************************
-   *                                                                         *
-   * Static Utilities                                                        *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Update the given filters with new ones, merging the two.
-   * The updated filters take precedence.
-   * @param filters
-   * @param updatedFilters
-   */
-  public static updateFilters(filters: Filter[], updatedFilters: Filter[]): Filter[] {
-    const filterMap = new Map<string, Filter>();
-
-    if (filters) {
-      filters.forEach(f => filterMap.set(f.key, f));
-    }
-
-    if (updatedFilters) {
-      updatedFilters.forEach(f => {
-        if (Filter.hasValue(f)) {
-          filterMap.set(f.key, f);
-        } else {
-          if (filterMap.has(f.key)) {
-            filterMap.delete(f.key);
-          }
-        }
-      });
-    }
-
-    return Array.from(filterMap.values());
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Read API                                                                *
-   *                                                                         *
-   **************************************************************************/
-
-  public get filters(): Observable<Filter[]> {
-    return this._filters$.asObservable().pipe(
-      distinctUntilChanged((a, b) => this.equals(a, b))
-    );
-  }
-
-  public get filtersSnapshot(): Filter[] {
-    return this._filters$.getValue();
-  }
-
-  public findFilterValue(key: string): string | string[] | undefined {
-    const f = this.findFilter(key);
-    return f ? f.value : undefined;
-  }
-
-  public findFilter(key: string): Filter | undefined {
-    return this.filtersSnapshot
-      .filter(f => f.key === key)
-      .find(first => true);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  public removeFilter(key: string): void {
-    const current = this.filtersSnapshot;
-    const newFilters = current.filter(f => f.key !== key);
-    if (current.length !== newFilters.length) {
-      this.replaceFilters(newFilters);
-    }
-  }
-
-  /**
-   * This method updatees / adds the given filter, leaving
-   * existing ones untouched.
-   * @param updatedFilter
-   */
-  public updateFilter(updatedFilter?: Filter): void {
-    if (updatedFilter) {
-      this.updateFilters([updatedFilter]);
-    }
-  }
-
-  /**
-   * This method updates / adds the given filters, leaving
-   * existing ones untouched.
-   * @param updatedFilters
-   */
-  public updateFilters(updatedFilters?: Filter[]): void {
-    if (updatedFilters && updatedFilters.length > 0) {
-      this.replaceFilters(
-        FilterContext.updateFilters(this.filtersSnapshot, updatedFilters)
-      );
-    }
-  }
-
-  /**
-   * Replace all existing filters with the given new ones.
-   * @param newFilters
-   */
-  public replaceFilters(newFilters?: Filter[]) {
-    this._filters$.next(newFilters || []);
-  }
-
-  public clear(): void {
-    this.replaceFilters([]);
-  }
-
-  public mergeFilters(filters: Filter[]){
-    filters.forEach(filter => this.mergeFilter(filter));
-  }
-
-  public mergeFilter(filter: Filter): void {
-    const existing = this.findFilter(filter.key);
-    if(!existing){
-      this.updateFilter(filter);
-    } else {
-      this.updateFilter(Filter.merge(existing, filter))
-    }
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-  private equals(aFilters: Filter[], bFilters: Filter[]): boolean {
-
-    if (aFilters.length !== bFilters.length) { return false; }
-    if (aFilters.length === 0 && bFilters.length === 0) { return true; }
-
-    // The both filter arrays have the same length, so we must compare them by value
-
-    const bIndex = new Map<string, Filter>();
-    bFilters.forEach(f => bIndex.set(f.key, f));
-
-    for (const fa of aFilters) {
-      const bFilter = bIndex.get(fa.key);
-      if (!Filter.equals(bFilter, fa)) {
-        return false;
-      }
-    }
-    return true;
-  }
-}

package/src/lib/common/data/filters/filter.spec.ts

@@ -1,136 +0,0 @@
-import {Filter} from './filter';
-
-describe('FilterTest', () => {
-
-  beforeEach(async () => {
-  });
-
-  beforeEach(() => {
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test hasValue                                                           *
-   *                                                                         *
-   **************************************************************************/
-
-  it('Filter.hasValue - single yes', () => {
-    const filter = new Filter('key', 'value');
-    expect(Filter.hasValue(filter)).toEqual(true);
-  });
-
-  it('Filter.hasValue - many yes', () => {
-    const filter = new Filter('key', ['a', 'b']);
-    expect(Filter.hasValue(filter)).toEqual(true);
-  });
-
-  it('Filter.hasValue - empty is value', () => { // Is this correct? (legacy behaviour)
-    const filter = new Filter('key', '');
-    expect(Filter.hasValue(filter)).toEqual(true);
-  });
-
-  it('Filter.hasValue - multi empty is value', () => { // Is this correct?  (legacy behaviour)
-    const filter = new Filter('key', ['']);
-    expect(Filter.hasValue(filter)).toEqual(true);
-  });
-
-  it('Filter.hasValue - 2 multi empty is value', () => { // Is this correct?  (legacy behaviour)
-    const filter = new Filter('key', ['', '']);
-    expect(Filter.hasValue(filter)).toEqual(true);
-  });
-
-  it('Filter.hasValue - single undefined', () => {
-    const filter = new Filter('key', undefined);
-    expect(Filter.hasValue(filter)).toEqual(false);
-  });
-
-  it('Filter.hasValue - single null', () => {
-    const filter = new Filter('key', null);
-    expect(Filter.hasValue(filter)).toEqual(false);
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test equals                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-  it('Filter.equals - single equal', () => {
-    const a = new Filter('key', 'xyz');
-    const b = new Filter('key', 'xyz');
-    expect(Filter.equals(a, b)).toEqual(true);
-  });
-
-  it('Filter.equals - single different', () => {
-    const a = new Filter('key', 'xyz');
-    const b = new Filter('key', 'xyt');
-    expect(Filter.equals(a, b)).toEqual(false);
-  });
-
-  it('Filter.equals - same value different key', () => {
-    const a = new Filter('key', 'xyz');
-    const b = new Filter('key2', 'xyz');
-    expect(Filter.equals(a, b)).toEqual(false);
-  });
-
-  it('Filter.equals - single wrapped equal', () => {
-    const a = new Filter('key', ['a']);
-    const b = new Filter('key', ['a']);
-    expect(Filter.equals(a, b)).toEqual(true);
-  });
-
-  it('Filter.equals - multi equal', () => {
-    const a = new Filter('key', ['a', 'b', 'c']);
-    const b = new Filter('key', ['a', 'b', 'c']);
-    expect(Filter.equals(a, b)).toEqual(true);
-  });
-
-  it('Filter.equals - multi set equal', () => {
-    const a = new Filter('key', ['a', 'b', 'c']);
-    const b = new Filter('key', ['c', 'b', 'a']);
-    expect(Filter.equals(a, b)).toEqual(true);
-  });
-
-  /***************************************************************************
-   *                                                                         *
-   * Test merge                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  it('Filter.merge - override with 2nd argument', () => {
-    const a = new Filter('key', 'a');
-    const b = new Filter('key', 'b');
-    expect(Filter.merge(a, b).value).toEqual('b');
-  });
-
-  it('Filter.merge - append when 2nd is array', () => {
-    const a = new Filter('key', 'a');
-    const b = new Filter('key', ['b']);
-    expect(Filter.merge(a, b).value).toEqual(['a', 'b']);
-  });
-
-  it('Filter.merge - append when 2nd is array', () => {
-    const a = new Filter('key', ['a']);
-    const b = new Filter('key', 'b');
-    expect(Filter.merge(a, b).value).toEqual(['a', 'b']);
-  });
-
-  it('Filter.merge - merge lists', () => {
-    const a = new Filter('key', ['a', 'b']);
-    const b = new Filter('key', 'c');
-    expect(Filter.merge(a, b).value).toEqual(['a', 'b', 'c']);
-  });
-
-  it('Filter.merge - merge lists 2', () => {
-    const a = new Filter('key', ['a', 'b']);
-    const b = new Filter('key', ['c', 'd']);
-    expect(Filter.merge(a, b).value).toEqual(['a', 'b', 'c', 'd']);
-  });
-
-  it('Filter.merge - merge lists 2 - avoid duplicates', () => {
-    const a = new Filter('key', ['a', 'b']);
-    const b = new Filter('key', ['c', 'a']);
-    expect(Filter.merge(a, b).value).toEqual(['a', 'b', 'c']);
-  });
-
-});