@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

package/lib/common/time/interval.d.ts

@@ -0,0 +1,287 @@
+import { Duration, Instant, LocalDate, TemporalAmount, ZoneId } from '@js-joda/core';
+import { PeriodDuration } from './period-duration';
+/**
+ * Represents an ISO-8601 interval string.
+ * https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+ */
+export declare type IsoIntervalStr = string;
+export declare class Interval {
+    readonly start: Instant;
+    readonly end: Instant;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(start: Instant, end: Instant);
+    /***************************************************************************
+     *                                                                         *
+     * Static Builders                                                         *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Parses an ISO-8601 interval string.
+     * https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
+     * @param iso
+     */
+    static parse(iso: IsoIntervalStr): Interval;
+    static yesterday(zoneId: ZoneId): Interval;
+    static tomorrow(zoneId: ZoneId): Interval;
+    static today(zoneId: ZoneId): Interval;
+    /**
+     * Creates a Interval from a Date by spreading it to the begin and end of its day.
+     * @param date Date to spread
+     */
+    static ofDayDate(date: Date): Interval;
+    static ofDay(day: LocalDate, zoneId: ZoneId): Interval;
+    static betweenDays(startDayInclusive: LocalDate, endDayExclusive: LocalDate, zoneId: ZoneId): Interval;
+    /**
+     * Creates a new interval with the given start time point
+     * and a offset from the start.
+     *
+     * Note that you should use Period for days to account for zone specific
+     * things like daylight saving.
+     *
+     * @param startInclusive
+     * @param offsetExclusive A Period or Duration offset.
+     */
+    static ofStartAndOffset(startInclusive: Instant, offsetExclusive: TemporalAmount): Interval;
+    static of(startInclusive: Instant, endExclusive: Instant): Interval;
+    static ofDate(startInclusive: Date | string, endExclusive: Date | string): Interval;
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Checks if the range is empty.
+     * <p>
+     * An empty range occurs when the start date equals the inclusive end date.
+     *
+     * @return true if the range is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Checks if the start of the interval is unbounded.
+     *
+     * @return true if start is unbounded
+     */
+    isUnboundedStart(): boolean;
+    /**
+     * Checks if the end of the interval is unbounded.
+     *
+     * @return true if end is unbounded
+     */
+    isUnboundedEnd(): boolean;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    toDuration(): Duration;
+    toPeriodDuration(zone: ZoneId): PeriodDuration;
+    toString(): IsoIntervalStr;
+    toInstantString(): IsoIntervalStr;
+    toDurationString(): IsoIntervalStr;
+    /***************************************************************************
+     *                                                                         *
+     * Public Modification API                                                 *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Returns a copy of this range with the specified start instant.
+     *
+     * @param start  the start instant for the new interval, not null
+     * @return an interval with the end from this interval and the specified start
+     * @throws DateTimeException if the resulting interval has end before start
+     */
+    withStart(start: Instant): Interval;
+    /**
+     * Returns a copy of this range with the specified end instant.
+     *
+     * @param end  the end instant for the new interval, not null
+     * @return an interval with the start from this interval and the specified end
+     * @throws DateTimeException if the resulting interval has end before start
+     */
+    withEnd(end: Instant): Interval;
+    /**
+     * Calculates the interval that is the intersection of this interval and the specified interval.
+     * <p>
+     * This finds the intersection of two intervals.
+     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.
+     *
+     * @param other  the other interval to check for, not null
+     * @return the interval that is the intersection of the two intervals
+     * @throws DateTimeException if the intervals do not connect
+     */
+    intersection(other: Interval): Interval;
+    /**
+     * Calculates the interval that is the union of this interval and the specified interval.
+     * <p>
+     * This finds the union of two intervals.
+     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.
+     *
+     * @param other  the other interval to check for, not null
+     * @return the interval that is the union of the two intervals
+     * @throws DateTimeException if the intervals do not connect
+     */
+    union(other: Interval): Interval;
+    /**
+     * Calculates the smallest interval that encloses this interval and the specified interval.
+     * <p>
+     * The result of this method will {@linkplain #encloses(Interval) enclose}
+     * this interval and the specified interval.
+     *
+     * @param other  the other interval to check for, not null
+     * @return the interval that spans the two intervals
+     */
+    span(other: Interval): Interval;
+    /**
+     * Shift the whole interval by the given days period.
+     * @param days
+     */
+    shiftDays(days: number): Interval;
+    /**
+     * Shift the whole interval by the given temporal amount.
+     * Note that only Period will account for zone specific things such as daylight savings.
+     * Use Duration only if you are below days.
+     * @param offset
+     */
+    shift(offset: TemporalAmount): Interval;
+    moveStart(offset: TemporalAmount): Interval;
+    moveEnd(offset: TemporalAmount): Interval;
+    /***************************************************************************
+     *                                                                         *
+     * Interval Query API                                                      *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Checks if the given TimeFrame overlaps with this one.
+     *
+     * @param other TimeFrame to check against
+     * @return Returns {@code true} if the two candidates overlap, false otherwise
+     */
+    overlaps(other: Interval): boolean;
+    /**
+     * Checks it the given localDate overlaps with the given TimeFrame.
+     *
+     * @param timeFrame TimeFrame to check against
+     * @param localDate LocalDate to check
+     */
+    overlapsWithLocalDate(localDate: Date): boolean;
+    /**
+     * Checks if this interval contains the specified instant.
+     * <p>
+     * This checks if the specified instant is within the bounds of this interval.
+     * If this range has an unbounded start then {@code contains(Instant#MIN)} returns true.
+     * If this range has an unbounded end then {@code contains(Instant#MAX)} returns true.
+     * If this range is empty then this method always returns false.
+     *
+     * @param instant  the instant, not null
+     * @return true if this interval contains the instant
+     */
+    contains(instant: Instant): boolean;
+    /**
+     * Checks if this interval encloses the specified interval.
+     * <p>
+     * This checks if the bounds of the specified interval are within the bounds of this interval.
+     * An empty interval encloses itself.
+     *
+     * @param other  the other interval, not null
+     * @return true if this interval contains the other interval
+     */
+    encloses(other: Interval): boolean;
+    /**
+     * Checks if this interval abuts (is next to or has a common boundary with) the specified interval.
+     * <p>
+     * The result is true if the end of this interval is the start of the other, or vice versa.
+     * An empty interval does not abut itself.
+     *
+     * @param other  the other interval, not null
+     * @return true if this interval abuts the other interval
+     */
+    abuts(other: Interval): boolean;
+    /**
+     * Checks if this interval is connected to the specified interval.
+     * <p>
+     * The result is true if the two intervals have an enclosed interval in common, even if that interval is empty.
+     * An empty interval is connected to itself.
+     * <p>
+     * This is equivalent to {@code (overlaps(other) || abuts(other))}.
+     *
+     * @param other  the other interval, not null
+     * @return true if this interval is connected to the other interval
+     */
+    isConnected(other: Interval): boolean;
+    /**
+     * Checks if this interval is after the specified instant.
+     * <p>
+     * The result is true if this instant starts after the specified instant.
+     * An empty interval behaves as though it is an instant for comparison purposes.
+     *
+     * @param instant  the other instant to compare to, not null
+     * @return true if the start of this interval is after the specified instant
+     */
+    isAfterInstant(instant: Instant): boolean;
+    /**
+     * Checks if this interval is before the specified instant.
+     * <p>
+     * The result is true if this instant ends before the specified instant.
+     * Since intervals do not include their end points, this will return true if the
+     * instant equals the end of the interval.
+     * An empty interval behaves as though it is an instant for comparison purposes.
+     *
+     * @param instant  the other instant to compare to, not null
+     * @return true if the start of this interval is before the specified instant
+     */
+    isBeforeInstant(instant: Instant): boolean;
+    /**
+     * Checks if this interval is after the specified interval.
+     * <p>
+     * The result is true if this instant starts after the end of the specified interval.
+     * Since intervals do not include their end points, this will return true if the
+     * instant equals the end of the interval.
+     * An empty interval behaves as though it is an instant for comparison purposes.
+     *
+     * @param interval  the other interval to compare to, not null
+     * @return true if this instant is after the specified instant
+     */
+    isAfter(interval: Interval): boolean;
+    /**
+     * Checks if this interval is before the specified interval.
+     * <p>
+     * The result is true if this instant ends before the start of the specified interval.
+     * Since intervals do not include their end points, this will return true if the
+     * two intervals abut.
+     * An empty interval behaves as though it is an instant for comparison purposes.
+     *
+     * @param interval  the other interval to compare to, not null
+     * @return true if this instant is before the specified instant
+     */
+    isBefore(interval: Interval): boolean;
+    /***************************************************************************
+       *                                                                         *
+       * Equality & Hashcode                                                     *
+       *                                                                         *
+       **************************************************************************/
+    /**
+     * Checks if this interval is equal to another interval.
+     * <p>
+     * Compares this {@code Interval} with another ensuring that the two instants are the same.
+     * Only objects of type {@code Interval} are compared, other types return false.
+     *
+     * @param obj  the object to check, null returns false
+     * @return true if this is equal to the other interval
+     */
+    equals(obj: any): boolean;
+    /**
+     * Compares this Interval to the given Interval.
+     * <p>
+     * The comparison is based on the time-line position of the lower bound instants (Interval start).
+     *
+     * @param other the other Interval to compare to, not null
+     * @return the comparator value, negative if less, positive if greater
+     * @throws NullPointerException if other is null
+     */
+    compareTo(other: Interval): number;
+}

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

@@ -0,0 +1,84 @@
+import { Duration, Period, Temporal } from '@js-joda/core';
+export declare class PeriodDuration {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    readonly period: Period;
+    readonly duration: Duration;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    private constructor();
+    /***************************************************************************
+     *                                                                         *
+     * 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
+     */
+    static parse(text: string): PeriodDuration;
+    /**
+     * 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
+     */
+    static between(startInclusive: Temporal, endExclusive: Temporal): PeriodDuration;
+    static ofPeriod(period: Period): PeriodDuration;
+    static ofDuration(duration: Duration): PeriodDuration;
+    static of(period: Period, duration: Duration): PeriodDuration;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { Duration, Instant, LocalDate, TemporalAccessor, ZonedDateTime, ZoneId } from '@js-joda/core';
+export declare class TimeUtil {
+    static readonly SECONDS_PER_DAY = 86400;
+    /**
+     * Returns an instant for a javascript date / iso date string.
+     * @param date
+     */
+    static instant(date: Date | string): Instant;
+    static dateToLocalDate(date: Date): LocalDate;
+    static temporalAccessor(date: Date): TemporalAccessor;
+    static date(instant: Instant): Date;
+    static localDateToDate(localDate: LocalDate, zone?: ZoneId): Date;
+    static isFullDays(duration: Duration): boolean;
+    static isStartOfDay(date: ZonedDateTime): boolean;
+}

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

@@ -0,0 +1,36 @@
+import { Router, UrlTree } from '@angular/router';
+import { Location } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ *
+ */
+export declare class ElderRouterService {
+    private router;
+    private location;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(router: Router, location: Location);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Open the given url in a new window / tab.
+     * @param urlTree
+     * @param target
+     */
+    openUrl(urlTree: UrlTree, target?: string): void;
+    serializeUrlAbsolute(urlTree: UrlTree): string;
+    serializeUrlExternal(urlTree: UrlTree): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElderRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElderRouterService>;
+}

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

@@ -0,0 +1,62 @@
+import { Observable } from 'rxjs';
+import { ActivatedRoute, Router } from '@angular/router';
+import { UrlQueryParams } from './url-query-params';
+import * as i0 from "@angular/core";
+/**
+ * Manages bidirectional binding of
+ * query params within the current URL fragment.
+ */
+export declare class ElderUrlFragmentParamsService {
+    private router;
+    private activatedRoute;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly _log;
+    private readonly _queryParams$;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(router: Router, activatedRoute: ActivatedRoute);
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get params$(): Observable<UrlQueryParams>;
+    get params(): UrlQueryParams;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Replaces all current params with the given ones.
+     */
+    setParams(params: UrlQueryParams): void;
+    /**
+     * Updates the current params with the given ones, effectively
+     * resulting in a merge.
+     */
+    updateParams(params: UrlQueryParams): void;
+    /**
+     * Clears all current params.
+     */
+    clearParams(): void;
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private setCurrentParams;
+    private updateModel;
+    private updateFragment;
+    private replaceUrlFragment;
+    private parseQueryParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElderUrlFragmentParamsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElderUrlFragmentParamsService>;
+}

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

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

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

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

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

@@ -0,0 +1,14 @@
+export declare class Batcher {
+    /**
+     * Batches the given items into batches of the given size.
+     */
+    static batch<V>(items: V[], batchSize: number): V[][];
+    /**
+     * Batches the given items into batches of the given size, and
+     * applies a mapping function to each batch.
+     * @param items
+     * @param batchSize
+     * @param mapper
+     */
+    static batchMap<V, R>(items: V[], batchSize: number, mapper: (slice: V[]) => R): R[];
+}

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

@@ -0,0 +1,35 @@
+export declare class CollectionUtil {
+    private static readonly logger;
+    static flatten<T>(groups: T[][]): T[];
+    /**
+     * Moves the given item down in the given array - if not already at the bottom
+     * @param items
+     * @param toMove
+     */
+    static moveDown<T>(items: T[], toMove: T): boolean;
+    /**
+     * Moves the given item up in the given array - if not already at the top
+     * @param items
+     * @param toMove
+     */
+    static moveUp<T>(items: T[], toMove: T): boolean;
+    /**
+     * Groups the given items by the given field into a Map
+     */
+    static groupByField<G, T>(items: T[], field: string): Map<G, T[]>;
+    /**
+     * Groups the given items, using the group key getter, into a Map
+     * @dynamic
+     */
+    static groupByKey<G, T>(items: T[], keyGetter: ((item: T) => G)): Map<G, T[]>;
+    /**
+     * 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
+     */
+    static equalSetDeep<T>(aSet: Set<T>, bSet: Set<T>): boolean;
+    static hasElements(list: any[]): boolean;
+}

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

@@ -0,0 +1,7 @@
+import { Filter } from '../data/filters/filter';
+export declare class FilterUtil {
+    private static readonly logger;
+    static filterData<T>(data: T[], filters: Filter[]): T[];
+    private static matches;
+    private static matchesValue;
+}