@elderbyte/ngx-starter 14.10.0 → 14.11.1

package/src/lib/common/time/period-duration.ts

@@ -0,0 +1,147 @@
+import {Duration, LocalDate, LocalTime, Period, Temporal, TemporalQueries} from '@js-joda/core';
+
+export class PeriodDuration {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  public readonly period: Period;
+  public readonly duration: Duration;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  private constructor(
+    period: Period,
+    duration: Duration
+  ) {
+    this.period = period;
+    this.duration = duration;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Obtains an instance from a text string such as {@code PnYnMnDTnHnMnS}.
+   * <p>
+   * This will parse the string produced by {@code toString()} which is
+   * based on the ISO-8601 period formats {@code PnYnMnDTnHnMnS} and {@code PnW}.
+   * <p>
+   * The string starts with an optional sign, denoted by the ASCII negative
+   * or positive symbol. If negative, the whole amount is negated.
+   * The ASCII letter "P" is next in upper or lower case.
+   * There are then a number of sections, each consisting of a number and a suffix.
+   * At least one of the sections must be present.
+   * The sections have suffixes in ASCII of "Y" for years, "M" for months,
+   * "W" for weeks, "D" for days, "H" for hours, "M" for minutes, "S" for seconds,
+   * accepted in upper or lower case. Note that the ASCII letter "T" separates
+   * the date and time parts and must be present if any time part is present.
+   * The suffixes must occur in order.
+   * The number part of each section must consist of ASCII digits.
+   * The number may be prefixed by the ASCII negative or positive symbol.
+   * The number must parse to an {@code int}.
+   * Any week-based input is multiplied by 7 and treated as a number of days.
+   * <p>
+   * The leading plus/minus sign, and negative values for weeks and days are
+   * not part of the ISO-8601 standard.
+   * <p>
+   * Note that the date style format {@code PYYYY-MM-DDTHH:MM:SS} is not supported.
+   * <p>
+   * For example, the following are valid inputs:
+   * <pre>
+   *   "P2Y"             -- PeriodDuration.of(Period.ofYears(2))
+   *   "P3M"             -- PeriodDuration.of(Period.ofMonths(3))
+   *   "P4W"             -- PeriodDuration.of(Period.ofWeeks(4))
+   *   "P5D"             -- PeriodDuration.of(Period.ofDays(5))
+   *   "PT6H"            -- PeriodDuration.of(Duration.ofHours(6))
+   *   "P1Y2M3D"         -- PeriodDuration.of(Period.of(1, 2, 3))
+   *   "P1Y2M3W4DT8H"    -- PeriodDuration.of(Period.of(1, 2, 25), Duration.ofHours(8))
+   *   "P-1Y2M"          -- PeriodDuration.of(Period.of(-1, 2, 0))
+   *   "-P1Y2M"          -- PeriodDuration.of(Period.of(-1, -2, 0))
+   * </pre>
+   *
+   * @param text  the text to parse, not null
+   * @return the parsed period, not null
+   * @throws DateTimeParseException if the text cannot be parsed to a period
+   */
+  public static parse(text: string): PeriodDuration {
+    // Objects.requireNonNull(text, "text");
+    let upper = text.toString().toUpperCase();
+    let negate = '';
+    if (upper.startsWith('+')) {
+      upper = upper.substring(1);
+    } else if (upper.startsWith('-')) {
+      upper = upper.substring(1);
+      negate = '-';
+    }
+    // duration only, parse original text so it does negation
+    if (upper.startsWith('PT')) {
+      return PeriodDuration.ofDuration(Duration.parse(text));
+    }
+    // period only, parse original text so it does negation
+    const tpos = upper.indexOf('T');
+    if (tpos < 0) {
+      return PeriodDuration.ofPeriod(Period.parse(text));
+    }
+    // period and duration
+    const period = Period.parse(negate + upper.substring(0, tpos));
+    const duration = Duration.parse(negate + 'P' + upper.substring(tpos));
+    return PeriodDuration.of(period, duration);
+  }
+
+  /**
+   * Obtains an instance consisting of the amount of time between two temporals.
+   * <p>
+   * The start is included, but the end is not.
+   * The result of this method can be negative if the end is before the start.
+   * <p>
+   * The calculation examines the temporals and extracts {@link LocalDate} and {@link LocalTime}.
+   * If the time is missing, it will be defaulted to midnight.
+   * If one date is missing, it will be defaulted to the other date.
+   * It then finds the amount of time between the two dates and between the two times.
+   *
+   * @param startInclusive  the start, inclusive, not null
+   * @param endExclusive  the end, exclusive, not null
+   * @return the number of days between this date and the end date, not null
+   */
+  public static between(startInclusive: Temporal, endExclusive: Temporal): PeriodDuration {
+    const startDate = startInclusive.query(TemporalQueries.localDate());
+    const endDate = endExclusive.query(TemporalQueries.localDate());
+    let period = Period.ZERO;
+    if (startDate != null && endDate != null) {
+      period = Period.between(startDate, endDate);
+    }
+    let startTime = startInclusive.query(TemporalQueries.localTime());
+    let endTime = endExclusive.query(TemporalQueries.localTime());
+    startTime = startTime != null ? startTime : LocalTime.MIDNIGHT;
+    endTime = endTime != null ? endTime : LocalTime.MIDNIGHT;
+    const duration = Duration.between(startTime, endTime);
+    return PeriodDuration.of(period, duration);
+  }
+
+  public static ofPeriod(period: Period): PeriodDuration {
+    return PeriodDuration.of(period, Duration.ZERO);
+  }
+
+  public static ofDuration(duration: Duration): PeriodDuration {
+    return PeriodDuration.of(Period.ZERO, duration);
+  }
+
+  public static of(period: Period, duration: Duration): PeriodDuration {
+
+    if (!period) { throw new Error('Parameter period must not be null!'); }
+    if (!period) { throw new Error('Parameter duration must not be null!'); }
+
+    return new PeriodDuration(period, duration);
+  }
+}

package/src/lib/common/time/public_api.ts

@@ -0,0 +1,6 @@
+
+
+export * from './period-duration';
+export * from './interval';
+export * from './time-util';
+export * from './date-util';

package/src/lib/common/time/time-util.ts

@@ -0,0 +1,54 @@
+import {Duration, Instant, LocalDate, nativeJs, TemporalAccessor, ZonedDateTime, ZoneId} from '@js-joda/core';
+
+export class TimeUtil {
+
+  public static readonly SECONDS_PER_DAY = 86400;
+
+  /**
+   * Returns an instant for a javascript date / iso date string.
+   * @param date
+   */
+  public static instant(date: Date | string): Instant {
+    if (date instanceof Date) {
+      return Instant.from(TimeUtil.temporalAccessor(date));
+    } else {
+      return Instant.parse(date);
+    }
+  }
+
+  public static dateToLocalDate(date: Date): LocalDate {
+    return LocalDate.from(TimeUtil.temporalAccessor(date));
+  }
+
+  public static temporalAccessor(date: Date): TemporalAccessor {
+    return nativeJs(date);
+  }
+
+  public static date(instant: Instant): Date {
+    const d = new Date(0); // The 0 there is the key, which sets the date to the epoch
+    d.setUTCMilliseconds(instant.toEpochMilli());
+    return d;
+  }
+
+  public static localDateToDate(localDate: LocalDate, zone = ZoneId.systemDefault()): Date {
+    return new Date(
+      localDate.year(),
+      localDate.monthValue() - 1,
+      localDate.dayOfMonth(),
+      0, 0, 0, 0
+    );
+  }
+
+  public static isFullDays(duration: Duration): boolean {
+    const r = duration.seconds() % TimeUtil.SECONDS_PER_DAY;
+    return r === 0;
+  }
+
+  public static isStartOfDay(date: ZonedDateTime): boolean {
+    return date.second() === 0
+      && date.minute() === 0
+      && date.hour() === 0
+      && date.nano() === 0
+      ;
+  }
+}

package/src/lib/common/url/elder-router.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import {Router, UrlTree} from '@angular/router';
+import {Location} from '@angular/common';
+
+/**
+ * Provides advanced router navigation support for Angular.
+ *
+ * Provides the ability to build external & absolute urls which
+ * can be used in iframes or external navigation, such as opening
+ * new tabs.
+ *
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ElderRouterService {
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private router: Router,
+    private location: Location,
+  ) { }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Open the given url in a new window / tab.
+   * @param urlTree
+   * @param target
+   */
+  public openUrl(urlTree: UrlTree, target?: string): void {
+    const absoluteUrl = this.serializeUrlAbsolute(urlTree);
+    window.open(absoluteUrl, target);
+  }
+
+  public serializeUrlAbsolute(urlTree: UrlTree): string {
+    const externalUrl = this.serializeUrlExternal(urlTree);
+    return window.location.origin + externalUrl;
+  }
+
+  public serializeUrlExternal(urlTree: UrlTree): string {
+    const url = this.router.serializeUrl(urlTree);
+    return this.location.prepareExternalUrl(url);
+  }
+
+}

package/src/lib/common/url/elder-url-fragment-params.service.ts

@@ -0,0 +1,139 @@
+import {Injectable} from '@angular/core';
+import {BehaviorSubject, Observable} from 'rxjs';
+import {ActivatedRoute, Router} from '@angular/router';
+import {UrlQueryParams} from './url-query-params';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+
+
+/**
+ * Manages bidirectional binding of
+ * query params within the current URL fragment.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ElderUrlFragmentParamsService {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly _log = LoggerFactory.getLogger(this.constructor.name);
+
+  private readonly _queryParams$ = new BehaviorSubject<UrlQueryParams>(UrlQueryParams.empty());
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private router: Router,
+    private activatedRoute: ActivatedRoute
+  ) {
+    this.activatedRoute
+      .fragment
+      .subscribe(
+        fragment => {
+          const params = this.parseQueryParams(fragment);
+          this.updateModel(params);
+        }
+      );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get params$(): Observable<UrlQueryParams> {
+    return this._queryParams$.asObservable();
+  }
+
+  public get params(): UrlQueryParams {
+    return new UrlQueryParams(this._queryParams$.getValue());
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Replaces all current params with the given ones.
+   */
+  public setParams(params: UrlQueryParams): void {
+    // Create new instance to trigger change detection on subscribers.
+    const updated = new UrlQueryParams(params);
+    this.setCurrentParams(updated);
+  }
+
+  /**
+   * Updates the current params with the given ones, effectively
+   * resulting in a merge.
+   */
+  public updateParams(params: UrlQueryParams): void {
+    // Create new instance to trigger change detection on subscribers.
+    const updated = this.params;
+    updated.setAll(params.getAll());
+    this.setCurrentParams(updated);
+  }
+
+  /**
+   * Clears all current params.
+   */
+  public clearParams(): void {
+    this.setCurrentParams(UrlQueryParams.empty());
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private Methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private setCurrentParams(params: UrlQueryParams): void {
+    this.updateModel(params);
+    this.updateFragment(params);
+  }
+
+  private updateModel(params: UrlQueryParams): void {
+    this._queryParams$.next(params);
+  }
+
+  private updateFragment(queryParams: UrlQueryParams): void {
+    const queryParamsStr = queryParams.toString();
+
+    // Since both URLSearchParams.toString and angular router.navigate use encodeURIComponent
+    // we need to decode the component to avoid duplicate encoding.
+    const fragmentStr = decodeURIComponent(queryParamsStr);
+    this.replaceUrlFragment(fragmentStr);
+  }
+
+  private replaceUrlFragment(fragment: string): void {
+    this._log.trace('Replacing URL fragment with: ' + fragment);
+    this.router.navigate([], {
+      fragment: decodeURIComponent(fragment),
+      replaceUrl: true, // if true, won't add a new browser history entry
+      queryParamsHandling: 'merge'
+    });
+  }
+
+  private parseQueryParams(queryParamsStr: string): UrlQueryParams {
+
+    // avoids invalid search params
+    if (queryParamsStr) {
+      return new UrlQueryParams(queryParamsStr);
+    } else {
+      return new UrlQueryParams();
+    }
+
+  }
+
+
+}

package/src/lib/common/url/public_api.ts

@@ -0,0 +1,5 @@
+
+
+export * from './url-query-params';
+export * from './elder-url-fragment-params.service';
+export * from './elder-router.service'

package/src/lib/common/url/url-query-params.ts

@@ -0,0 +1,169 @@
+/**
+ * Utility class for handling query params.
+ */
+export class UrlQueryParams {
+
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+
+    /**
+     * Internal data context holding all query params.
+     */
+    private readonly _searchParams: URLSearchParams;
+
+    /***************************************************************************
+     *                                                                         *
+     * Static                                                                  *
+     *                                                                         *
+     **************************************************************************/
+
+    /**
+     * Creates a new empty UrlQueryParams object.
+     */
+    public static empty(): UrlQueryParams {
+        return new UrlQueryParams();
+    }
+
+    /**
+     * Parses the given string into a UrlQueryParams object.
+     */
+    public static parse(queryParamsStr: string): UrlQueryParams {
+        return new UrlQueryParams(queryParamsStr);
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+
+    public constructor(init?: string[][] | Record<string, string> | string | URLSearchParams | UrlQueryParams) {
+
+        if (init instanceof UrlQueryParams) {
+            this._searchParams = new URLSearchParams(init.toString());
+        } else {
+            this._searchParams = new URLSearchParams(init);
+        }
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+
+    /**
+     * Appends a new query parameter with the given key / value,
+     * regardless if the same parameter is already present.
+     */
+    public append(key: string, value: string): this {
+        this._searchParams.append(key, value);
+        return this;
+    }
+
+    /**
+     * Appends each of the given parameters as new query parameter,
+     * regardless if the same parameter is already present.
+     */
+    public appendAll(params: Map<string, string>): this {
+        params.forEach((value, key) => this.append(key, value));
+        return this;
+    }
+
+    /**
+     * Removes the given query parameter if present.
+     */
+    public remove(key: string): this {
+        this._searchParams.delete(key);
+        return this;
+    }
+
+    /**
+     * Removes all given query parameters if present.
+     */
+    public removeAll(keys: string[]): this {
+        keys.forEach(key => this.remove(key));
+        return this;
+    }
+
+    /**
+     * Updates the given query parameter with the given new value.
+     * If multiple with the same key exists, they will be removed.
+     * If the key does not exist, the query param will be added.
+     */
+    public set(key: string, value: string): this {
+        this._searchParams.set(key, value);
+        return this;
+    }
+
+    /**
+     * Updates each parameter with the given value.
+     * Each entry will be added using the set(key, value) logic.
+     */
+    public setAll(params: Map<string, string>): this {
+        params.forEach((value, key) => this.set(key, value));
+        return this;
+    }
+
+    /**
+     * Returns true if a query parameter with the given key exists.
+     */
+    public has(key: string): boolean {
+        return this._searchParams.has(key);
+    }
+
+    /**
+     * Returns the first value of the associated query param.
+     */
+    public get(key: string): string {
+        return this._searchParams.get(key);
+    }
+
+    /**
+     * Returns all values of the associated query params.
+     */
+    public getAllOf(key: string): string[] {
+        return this._searchParams.getAll(key);
+    }
+
+    /**
+     * Returns a map with all key-value pairs.
+     */
+    public getAll(): Map<string, string> {
+        const paramsMap = new Map<string, string>();
+        this._searchParams.forEach((value, key) => paramsMap.set(key, value));
+        return paramsMap;
+    }
+
+    /**
+     * Returns true only if there are any query parameters present.
+     */
+    public hasParams(): boolean {
+        return !this.isEmpty();
+    }
+
+    /**
+     * Return true only if there are no query parameters present.
+     */
+    public isEmpty(): boolean {
+        return this.getAll().size === 0;
+    }
+
+    /**
+     * Returns a string containing all query parameters in URL conform fashion.
+     * (Returns an empty string if no query parameters have been set).
+     */
+    public toString(): string {
+        return this._searchParams.toString();
+    }
+
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+
+}

package/src/lib/common/utils/batcher.spec.ts

@@ -0,0 +1,39 @@
+import {Batcher} from './batcher';
+
+describe('BatcherTest', () => {
+
+  beforeEach(async () => {
+  });
+
+  beforeEach(() => {
+  });
+
+
+  it('Batch empty array', () => {
+    const items: string[] = [];
+    const batches = Batcher.batch(items, 3);
+    expect(batches.length).toEqual(0);
+  });
+
+  it('Batch single item', () => {
+    const items = ['a'];
+    const batches = Batcher.batch(items, 3);
+
+    expect(batches.length).toEqual(1);
+
+    expect(batches[0]).toEqual(['a']);
+  });
+
+  it('Batch simple array', () => {
+    const items = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
+    const batches = Batcher.batch(items, 3);
+
+    expect(batches.length).toEqual(3);
+
+    expect(batches[0]).toEqual(['a', 'b', 'c']);
+    expect(batches[1]).toEqual([ 'd', 'e', 'f']);
+    expect(batches[2]).toEqual(['g']);
+  });
+
+
+});

package/src/lib/common/utils/batcher.ts

@@ -0,0 +1,55 @@
+
+export class Batcher {
+
+  /**
+   * Batches the given items into batches of the given size.
+   */
+  public static batch<V>(
+    items: V[],
+    batchSize: number
+  ): V[][] {
+    return Batcher.batchMap(items, batchSize, slice => slice);
+  }
+
+  /**
+   * Batches the given items into batches of the given size, and
+   * applies a mapping function to each batch.
+   * @param items
+   * @param batchSize
+   * @param mapper
+   */
+  public static batchMap<V, R>(
+    items: V[],
+    batchSize: number,
+    mapper: (slice: V[]) => R
+  ): R[] {
+
+    if (!items || items.length <= 0) {
+      return []; // Nothing to batch
+    }
+
+    if (batchSize <= 0) {
+      throw new Error('Batch size must be >= 0 but was ' + batchSize);
+    }
+
+    const batches: R[] = [];
+
+    let start = 0;
+    let slice: V[] = [];
+
+    do {
+      slice = items.slice(start, start + batchSize);
+      if (slice.length > 0) {
+        batches.push(mapper(slice));
+        start = start + batchSize;
+      }
+    }while (slice.length > 0);
+
+    return batches;
+  }
+
+}
+
+
+
+