@elderbyte/ngx-starter 14.10.0 → 14.11.1

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

@@ -0,0 +1,122 @@
+
+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

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,136 @@
+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']);
+  });
+
+});