@elderbyte/ngx-starter 14.12.0-beta4 → 14.12.0-beta6

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

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

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

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

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

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

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

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

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

@@ -1,96 +0,0 @@
-/**
- * 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

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

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

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