@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

package/src/lib/common/utils/collection-util.ts

@@ -1,125 +0,0 @@
-import {LoggerFactory} from '@elderbyte/ts-logger';
-
-// @dynamic
-export class CollectionUtil {
-
-  private static readonly logger = LoggerFactory.getLogger('CollectionUtil');
-
-
-  public static flatten<T>(groups: T[][]): T[] {
-    return groups
-      .reduce((acc, val) => acc.concat(val), []);
-  }
-
-  /**
-   * Moves the given item down in the given array - if not already at the bottom
-   * @param items
-   * @param toMove
-   */
-  public static moveDown<T>(items: T[], toMove: T): boolean {
-
-    if (items.length < 2) { return false; }
-
-    const position = items.indexOf(toMove);
-
-    if (position >= 0) {
-
-      const targetIndex = position + 1;
-      const bottom = items.length - 1;
-      if (!(bottom < targetIndex)) {
-        items[position] = items[targetIndex];
-        items[targetIndex] = toMove;
-        return true;
-      } else {
-        this.logger.debug('Can not move item down since target index ' + targetIndex + ' is already at the bottom: ' + bottom);
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Moves the given item up in the given array - if not already at the top
-   * @param items
-   * @param toMove
-   */
-  public static moveUp<T>(items: T[], toMove: T): boolean {
-
-    if (items.length < 2) { return false; }
-
-    const position = items.indexOf(toMove);
-
-    if (position >= 0) {
-
-      const targetIndex = position - 1;
-
-      if (targetIndex >= 0) {
-        items[position] = items[targetIndex];
-        items[targetIndex] = toMove;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Groups the given items by the given field into a Map
-   */
-  // @dynamic
-  public static groupByField<G, T>(items: T[], field: string): Map<G, T[]> {
-    return CollectionUtil.groupByKey(items, it => (it as any)[field] as G);
-  }
-
-  /**
-   * Groups the given items, using the group key getter, into a Map
-   * @dynamic
-   */
-  // @dynamic
-  public static groupByKey<G, T>(items: T[], keyGetter: ((item: T) => G)): Map<G, T[]> {
-
-    return items.reduce((map, p) => {
-
-      let subset: T[];
-
-      const key = keyGetter(p);
-
-      if (map.has(key)) {
-        subset = map.get(key);
-      } else {
-        subset = [];
-        map.set(key, subset);
-      }
-      subset.push(p);
-      return map;
-    }, new Map());
-  }
-
-  /**
-   * Compares two sets values deep.
-   * If both sets have the same items, they are considered equal.
-   *
-   * Warning: Duplicate elements are ignored.
-   * @param aSet
-   * @param bSet
-   */
-  public static equalSetDeep<T>(aSet: Set<T>, bSet: Set<T>): boolean {
-
-    if (aSet === bSet) { return true; }
-
-    if (!aSet || !bSet) { return false; }
-    if (aSet.size !== bSet.size) { return false; } // Must have same length
-
-    for (const a of aSet) {
-      if (!bSet.has(a)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  public static hasElements(list: any[]): boolean {
-    return list !== null && list !== undefined && list.length > 0;
-  }
-
-}
-
-

package/src/lib/common/utils/filter-util.ts

@@ -1,67 +0,0 @@
-import {Filter} from '../data/filters/filter';
-import {LoggerFactory} from '@elderbyte/ts-logger';
-
-
-export class FilterUtil {
-
-  private static readonly logger = LoggerFactory.getLogger(FilterUtil.constructor.name);
-
-
-  public static filterData<T>(data: T[], filters: Filter[]): T[] {
-
-    FilterUtil.logger.debug('Filtering data with ' + data.length + ' items.', filters);
-
-    if (filters && filters.length > 0) {
-      for (const filter of filters) {
-        data = data.filter(e => FilterUtil.matches(e, filter));
-      }
-    }
-    return data;
-  }
-
-
-  private static matches(entity: any, filter: Filter): boolean {
-
-    if (filter.value === null || filter.value === undefined) {
-      return true;
-    }
-
-    let value: any;
-    if (entity === null || entity === undefined) {
-      value = null;
-    } else if (typeof entity === 'object') {
-      value = entity[filter.key];
-    } else {
-      value = String(entity); // Support filtering primitive values
-    }
-
-    if (Array.isArray(filter.value)) {
-      for (const val of filter.value) {
-        if (FilterUtil.matchesValue(value, val)) {
-          return true;
-        }
-      }
-      return false;
-    } else {
-      return FilterUtil.matchesValue(value, filter.value);
-    }
-  }
-
-
-  private static matchesValue(haystack: any, needle: string): boolean {
-    if (haystack === needle) {
-      return true;
-    }
-
-    if (haystack === null || haystack === undefined) {
-      return false;
-    }
-
-    const str = String(haystack);
-    const match = str.toLowerCase().startsWith(needle.toLowerCase());
-
-    // FilterUtil.logger.debug('Haystack: ' + str + ' starts with needle: ' + needle + ' --> ' + match);
-
-    return match;
-  }
-}

package/src/lib/common/utils/next-number-util.ts

@@ -1,102 +0,0 @@
-export class NextNumberUtil {
-
-  /***************************************************************************
-   *                                                                         *
-   * Public Methods                                                          *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Identifies the next lexicographically number of the given number string.
-   *
-   * <p>
-   *     '1'    ->  '2'
-   *     '1.1'  ->  '1.2'
-   *     '1.01' ->  '1.02'
-   *     '1.1a' ->  '1.1b'
-   *     '1.01a'->  '1.01b'
-   *
-   * @param numberStr
-   * @returns
-   */
-  public static nextNumber(numberStr: string): string {
-
-    let nextNumber = null;
-
-    const numberPartsPattern = /\d+|[a-zA-Z]+/g;
-    const numberParts = numberStr.match(numberPartsPattern);
-
-    let nextNumberPart = null;
-    let i = numberParts.length;
-
-    while (nextNumberPart == null && i > 0) {
-      i--;
-      nextNumberPart = this.nextPartialNumber(numberParts[i]);
-    }
-
-    if (nextNumberPart != null) {
-      const partToReplace = numberParts[i];
-      const startIndex = numberStr.lastIndexOf(partToReplace);
-      const length = partToReplace.length;
-      nextNumber = numberStr.substr(0, startIndex) + nextNumberPart + numberStr.substr(startIndex + length);
-    }
-
-    return (nextNumber != null) ? nextNumber : '9999';
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private Methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Tries to lexicographically increase the given string.
-   *
-   * <p>
-   *     'abc' -> 'abd'
-   *     'abz' -> 'ac'
-   *     '123' -> '124'
-   *     '01'  -> '02'
-   *
-   * @param numberStr
-   * @returns
-   */
-  private static nextPartialNumber(numberStr: string): string {
-
-    let result = null;
-    const number = +numberStr;
-
-    // number only contains digits
-    if (!isNaN(number)) {
-
-      const origLength = numberStr.length;
-      let nextNumber = (number + 1).toString();
-
-      // add leading zeros until new next number string
-      // is same length as orig number string
-      let zerosToAdd = origLength - nextNumber.length;
-      while (zerosToAdd > 0) {
-        zerosToAdd--;
-        nextNumber = '0' + nextNumber;
-      }
-
-      result = nextNumber;
-    } else {
-
-      let i = numberStr.length;
-      while (result == null && i > 0) {
-        const letter = numberStr.charAt(i - 1);
-        if (letter.toLowerCase() !== 'z') {
-          let code = letter.charCodeAt(0);
-          code++;
-          result = String.fromCharCode(code);
-        } else {
-          i--;
-        }
-      }
-    }
-
-    return result;
-  }
-}

package/src/lib/common/utils/ng-zone-utils.ts

@@ -1,18 +0,0 @@
-
-import { Observable, OperatorFunction } from 'rxjs';
-import { NgZone } from '@angular/core';
-
-/**
- * Runs the observable stream in the given Angular Zone.
- * @param zone The Angular Zone
- */
-export function runInZone<T>(zone: NgZone): OperatorFunction<T, T> {
-  return (source) => {
-    return new Observable(observer => {
-      const onNext = (value: T) => zone.run(() => observer.next(value));
-      const onError = (e: any) => zone.run(() => observer.error(e));
-      const onComplete = () => zone.run(() => observer.complete());
-      return source.subscribe(onNext, onError, onComplete);
-    });
-  };
-}

package/src/lib/common/utils/parse-util.ts

@@ -1,17 +0,0 @@
-export class ParseUtil {
-
-  /**
-   * Tries to parse a given value to a boolean.
-   * @param bool a value representing a boolean state.
-   * @return undefined, if the value is null or undefined, false, if the value is false, else true.
-   */
-  public static parseBoolean(bool: any): boolean {
-
-      if (bool === undefined || bool == null) {
-        return undefined;
-      } else {
-        return !(bool === 'false' || bool === false);
-      }
-    }
-
-}

package/src/lib/common/utils/property-path-util.ts

@@ -1,29 +0,0 @@
-
-export class PropertyPathUtil {
-
-  /**
-   * Resolve the value of the given object under the given path
-   * @param object
-   * @param path A dot path like: test.name
-   */
-  public static resolveValue(object: any, path: string): any {
-    if (path && path.length > 0) {
-      const subPaths = path.split('\.');
-      subPaths.shift();
-      let current = object;
-
-      while (current && subPaths.length > 0) {
-        const sub = subPaths.shift();
-        if (sub) {
-          current = current[sub as string];
-        } else {
-          break;
-        }
-      }
-      return current;
-    } else {
-      return object;
-    }
-  }
-
-}

package/src/lib/common/utils/query-list-binding.ts

@@ -1,105 +0,0 @@
-import {QueryList} from '@angular/core';
-import {Observable, Subscription} from 'rxjs';
-import {map, startWith, takeUntil} from 'rxjs/operators';
-
-/**
- * Makes binding to a query list easy.
- */
-// @dynamic
-export class QueryListBinding<T> {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private valuesUpdatedFn: (values: T[]) => void;
-  private completedFn: (values: T[]) => void;
-
-  /***************************************************************************
-   *                                                                         *
-   * Static Builder                                                          *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Bind to the given QueryList until destroy$ is emitted.
-   * @param queryList
-   * @param destroy$
-   */
-  public static of<T>(
-    queryList: QueryList<T>,
-  ): QueryListBinding<T> {
-    return new QueryListBinding<T>(queryList);
-  }
-
-  public static asColdObservable<T>(queryList: QueryList<T>): Observable<T[]> {
-    return queryList.changes.pipe(
-      startWith(queryList),
-      map(x => queryList.toArray())
-    );
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Constructor                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-
-  constructor(
-    private readonly queryList: QueryList<T>,
-  ) {
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Callback which is invoked when the query list has new values.
-   * Note that this callback is also invoked initially.
-   * @param valuesFn
-   */
-  public updated(valuesFn: (values: T[]) => void): this {
-    this.valuesUpdatedFn = valuesFn;
-    return this;
-  }
-
-  /**
-   * Callback which is invoked when the binding is destroyed.
-   * Users can handle clean up here.
-   * @param completedFn
-   */
-  public destroyed(completedFn: (values: T[]) => void): this {
-    this.completedFn = completedFn;
-    return this;
-  }
-
-  public bindUntil(destroy$: Observable<any>): void {
-    this.subscribeToQueryList(this.queryList, destroy$);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-  private subscribeToQueryList(
-    queryList: QueryList<T>,
-    destroy$: Observable<any>
-  ): Subscription {
-    return QueryListBinding.asColdObservable(queryList).pipe(
-      takeUntil(destroy$),
-    ).subscribe(
-      values => this.valuesUpdatedFn ? this.valuesUpdatedFn(values) : {},
-      err => {
-      },
-      () => this.completedFn ? this.completedFn(Array.from(queryList)) : {}
-    );
-  }
-}

package/src/lib/common/utils/sort-util.spec.ts

@@ -1,41 +0,0 @@
-import {SortUtil} from './sort-util';
-import {Sort} from '../data/sort';
-
-describe('SortUtilTest', () => {
-
-  beforeEach(async () => {
-  });
-
-  beforeEach(() => {
-  });
-
-  it('sortData by property', () => {
-
-    class Dog {
-
-      constructor(
-        public name: string,
-        public age: number,
-        public fur: string
-      ) {
-      }
-    }
-
-    const dogs: Dog[] = [];
-
-    dogs.push(new Dog('virgo', 7, 'long'))
-    dogs.push(new Dog('aries', 1.5, 'silky'))
-    dogs.push(new Dog('libra', 3, 'fuzzy'))
-    dogs.push(new Dog('libra', 3, 'curly'))
-
-    const sorted = SortUtil.sortData(dogs, [new Sort('name', 'asc'), new Sort('fur', 'asc')])
-
-    expect(sorted[0].name).toEqual('aries');
-    expect(sorted[1].name).toEqual('libra');
-    expect(sorted[1].fur).toEqual('curly');
-    expect(sorted[2].name).toEqual('libra');
-    expect(sorted[2].fur).toEqual('fuzzy');
-    expect(sorted[3].name).toEqual('virgo');
-
-  });
-});

package/src/lib/common/utils/sort-util.ts

@@ -1,38 +0,0 @@
-import {Sort} from '../data/sort';
-import {ComparatorBuilder} from '../data/field-comparator';
-
-
-export class SortUtil {
-
-  public static sortData<T>(data: T[], sorts: Sort[]): T[] {
-
-    if (sorts && sorts.length > 0) {
-      const copy = [...data];
-      const sortFields = sorts.map(s => (s.dir === 'desc' ? '-' : '') +  s.prop);
-      return copy.sort(ComparatorBuilder.fieldSort(...sortFields));
-    } else {
-      return data;
-    }
-  }
-
-  /**
-   * Checks if the two arrays have all content references in the exact same order.
-   * @param data
-   * @param other
-   */
-  public static equalsExactRefs<T>(
-    data: T[],
-    other: T[]
-  ): boolean {
-    if (data.length == other.length) {
-      for (let i = 0; i < data.length; i++) {
-        if(data[i] != other[i]) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
-}

package/src/lib/common/utils/url-builder.spec.ts

@@ -1,83 +0,0 @@
-import {UrlBuilder} from './url-builder';
-
-describe('UrlBuilderTest', () => {
-
-  beforeEach(async () => {
-  });
-
-  beforeEach(() => {
-  });
-
-  it('parse and build simple url', () => {
-    const originalUrl = 'https://www.google.ch';
-    const urlBuilder = UrlBuilder.parse(originalUrl);
-    const url = urlBuilder.build();
-
-    expect(urlBuilder.protocol).toEqual('https:');
-    expect(urlBuilder.hostname).toEqual('www.google.ch');
-    expect(urlBuilder.host).toEqual('www.google.ch');
-    expect(urlBuilder.port).toEqual('');
-    expect(urlBuilder.path).toEqual('/');
-
-    expect(urlBuilder.queryString).toEqual('');
-    expect(urlBuilder.hasParams()).toBeFalsy();
-
-    expect(urlBuilder.username).toEqual('');
-    expect(urlBuilder.password).toEqual('');
-    expect(urlBuilder.hash).toEqual('');
-
-    expect(url).toEqual(originalUrl);
-  });
-
-  it('parse and build complex url', () => {
-    const originalUrl = 'https://max:muster@www.google.ch:444/this/is/a/path?param1=nicely%2Bencoded&param2=bar&param2=bar2#myHash';
-    const urlBuilder = UrlBuilder.parse(originalUrl);
-    const url = urlBuilder.build();
-
-    expect(urlBuilder.protocol).toEqual('https:');
-    expect(urlBuilder.hostname).toEqual('www.google.ch');
-    expect(urlBuilder.host).toEqual('www.google.ch:444');
-    expect(urlBuilder.port).toEqual('444');
-    expect(urlBuilder.path).toEqual('/this/is/a/path');
-
-    expect(urlBuilder.hasParams()).toBeTruthy();
-    expect(urlBuilder.getParam('param1')).toEqual('nicely+encoded');
-    expect(urlBuilder.getParam('param2')).toEqual('bar');
-    expect(urlBuilder.getParams('param2')).toEqual(['bar', 'bar2']);
-
-    expect(urlBuilder.username).toEqual('max');
-    expect(urlBuilder.password).toEqual('muster');
-    expect(urlBuilder.hash).toEqual('#myHash');
-
-    expect(url).toEqual(originalUrl);
-  });
-
-  it('build url', () => {
-    const url = UrlBuilder.start()
-      .withProtocol('http')
-      .withHostname('www.google.ch')
-      .withPath('/my/path')
-      .appendParam('param1', 'nicely+encoded')
-      .appendParam('param2', 'bar')
-      .build();
-
-    expect(url).toEqual('http://www.google.ch/my/path?param1=nicely%2Bencoded&param2=bar');
-  });
-
-
-  it('parse and alter complex url', () => {
-    const url = UrlBuilder.parse('http://www.google.ch/this/is/a/path?param1=nicely%2Bencoded')
-      .withProtocol('https')
-      .withPort('222')
-      .withPath('/altered/path')
-      .removeParam('param1')
-      .appendParam('param2', 'bar')
-      .withHash('myHash')
-      .withUsername('max')
-      .withPassword('muster')
-      .build();
-
-    expect(url).toEqual('https://max:muster@www.google.ch:222/altered/path?param2=bar#myHash');
-  });
-
-});