@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@elderbyte/ngx-starter" />
+export * from './public_api';

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

@@ -0,0 +1 @@
+export * from './refreshing-entity';

package/lib/common/async/refreshing-entity.d.ts

@@ -0,0 +1,55 @@
+import { Observable } from 'rxjs';
+import { IDataSource } from '../data/datasource/data-source';
+/**
+ * Represents an entity which can refresh itself periodically
+ * until a defined condition is met.
+ */
+export declare class RefreshingEntity<T> {
+    private readonly dataSource;
+    private readonly entity;
+    private readonly refreshPredicate;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly log;
+    private readonly current$;
+    private readonly entityId;
+    private readonly interval;
+    private readonly _refreshing$;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    static refreshWhile<T>(entity: T, dataSource: IDataSource<T>, refreshPredicate: (entity: T) => boolean, interval?: number): RefreshingEntity<T>;
+    static of<T>(fallback: T): RefreshingEntity<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataSource: IDataSource<T>, entity: T, refreshPredicate: (entity: T) => boolean, interval?: number);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Gets the entity stream which is periodically refreshed.
+     */
+    get entity$(): Observable<T>;
+    /**
+     * Gets the current entity value as snapshot
+     */
+    get entitySnapshot(): T;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private keepRefreshing;
+    private refresh;
+    private handleRefreshError;
+}

package/lib/common/csv/csv-serializer.d.ts

@@ -0,0 +1,33 @@
+import { CsvSpec } from './csv-spec';
+import { Observable } from 'rxjs/internal/Observable';
+import { TranslateService } from '@ngx-translate/core';
+export declare class CsvSerializer<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly _csvSpec;
+    private readonly _translateService;
+    constructor(csvSpec: CsvSpec<T>, translateService?: TranslateService);
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get csvSpec(): CsvSpec<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    serializeHeaders(): Observable<string>;
+    serializeRow(record: T): string;
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private getTranslatedHeaders;
+    private resolveValue;
+}

package/lib/common/csv/csv-spec.d.ts

@@ -0,0 +1,71 @@
+import { CsvSerializer } from './csv-serializer';
+import { TranslateService } from '@ngx-translate/core';
+export declare class CsvSpec<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    /** File name of CSV File */
+    filename: string;
+    /** Delimiter used */
+    delimiter: string;
+    /** Column specifications */
+    columnSpecs: CsvColumnSpec<T>[];
+    /** If Column header should be included */
+    includeHeader: boolean;
+    /***************************************************************************
+     *                                                                         *
+     * Static                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    static start<T>(filename: string): CsvSpec<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor();
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    getSerializer(translateService?: TranslateService): CsvSerializer<T>;
+    getHeaderTexts(): string[];
+    /***************************************************************************
+     *                                                                         *
+     * Fluent API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    withFilename(filename: string): CsvSpec<T>;
+    withDelimiter(delimiter: string): CsvSpec<T>;
+    withColumnSpecs(...columnSpec: CsvColumnSpec<T>[]): CsvSpec<T>;
+    addColumnSpec(headerText: string, valueResolverFn: (type: T) => string, id?: string): CsvSpec<T>;
+}
+export declare class CsvColumnSpec<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    /** ID used for identification of the column */
+    columnId: string;
+    /** Display string of the column header */
+    columnHeaderText: string;
+    /** Function to resolve the value of the record. */
+    valueResolverFn: (record: T) => string;
+    /***************************************************************************
+     *                                                                         *
+     * Static                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    static start<T>(id?: string): CsvColumnSpec<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Fluent API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    withColumnHeaderText(columnHeaderText: string): CsvColumnSpec<T>;
+    withValueResolverFn(fn: (record: T) => string): CsvColumnSpec<T>;
+}

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

@@ -0,0 +1,2 @@
+export * from './csv-spec';
+export * from './csv-serializer';

package/lib/common/data/continuable-listing.d.ts

@@ -0,0 +1,28 @@
+export declare class ContinuableListing<T> {
+    /**
+     * The data of this listing chunk
+     */
+    content: T[];
+    /**
+     * The current continuation token of this listing.
+     * To fetch the next page, use the NextContinuationToken property not this!
+     */
+    continuationToken?: string;
+    /**
+     * The continuation token to fetch the next part
+     */
+    nextContinuationToken?: string;
+    /**
+     * The totalSnapshot number of elements
+     * Might be null if the server does not know this
+     */
+    total?: number | undefined;
+    /**
+     * Size of this chunk (max page size)
+     */
+    chunkSize: number;
+    /**
+     * Is there more data to load with the NextContiunationToken?
+     */
+    hasMore: boolean;
+}

package/lib/common/data/data-context/data-context-active-page.d.ts

@@ -0,0 +1,75 @@
+import { DataContextBase } from './data-context-base';
+import { PageRequest } from '../page';
+import { Filter } from '../filters/filter';
+import { Observable } from 'rxjs';
+import { IDataContextActivePage } from './data-context';
+import { Sort } from '../sort';
+import { IPagedDataSource } from '../datasource/data-source';
+export declare class DataContextActivePage<T> extends DataContextBase<T> implements IDataContextActivePage<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly actlogger;
+    private readonly _page;
+    /**
+     * Subscription to the event when the active page has changed.
+     * This will trigger a page reload.
+     */
+    private _activePageChangedSub;
+    /**
+     * Subscription of an actual page load http request.
+     * If this is closed, it will cancel the http request.
+     */
+    private _activePageLoad;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataSource: IPagedDataSource<T>, pageSize: number, indexFn: ((item: T) => any), localApply: ((data: T[]) => T[]), localSort: ((data: T[], sorts: Sort[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataSource(): IPagedDataSource<T>;
+    get page(): Observable<PageRequest>;
+    get pageSnapshot(): PageRequest;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Set the current page index and reload.
+     * @param pageIndex
+     */
+    setActiveIndex(pageIndex: number): void;
+    /**
+     * Sets the current page index / size and reload.
+     */
+    setActivePage(request: PageRequest): void;
+    close(): void;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    protected clearAll(): void;
+    protected reloadInternal(): Observable<any>;
+    /***************************************************************************
+     *                                                                         *
+     * Event handlers                                                          *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Occurs when the sorts property has changed.
+     */
+    protected onSortsChanged(sorts: Sort[]): void;
+    /**
+     * Occurs when the filtersSnapshot property has changed.
+     */
+    protected onFiltersChanged(filters: Filter[]): void;
+}

package/lib/common/data/data-context/data-context-auto-starter.d.ts

@@ -0,0 +1,41 @@
+import { IDataContext } from './data-context';
+import { DataContextLifeCycleBinding } from './data-context-life-cycle-binding';
+import { Sort } from '../sort';
+export declare class AutoStartSpec {
+    requiredFilters?: Array<string[]>;
+    initialSort?: Sort[];
+    static asap(sort?: Sort[]): AutoStartSpec;
+    static requireFiltersAll(filters: string[], sort?: Sort[]): AutoStartSpec;
+    static requireFiltersAny(filters: string[], sort?: Sort[]): AutoStartSpec;
+    static requireFilters(filters: Array<string[]>, sort?: Sort[]): AutoStartSpec;
+    constructor(requiredFilters?: Array<string[]>, initialSort?: Sort[]);
+}
+export declare class DataContextAutoStarter extends DataContextLifeCycleBinding {
+    private readonly _autoStartSpec;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private readonly _autoStartConditionFulfilled$;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataContext: IDataContext<any>, _autoStartSpec: AutoStartSpec);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    protected subscribe(): void;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private buildRequiredFilterConditionObservable;
+    private startDataContext;
+}

package/lib/common/data/data-context/data-context-base.d.ts

@@ -0,0 +1,149 @@
+import { Filter } from '../filters/filter';
+import { Sort } from '../sort';
+import { CollectionViewer, DataSource } from '@angular/cdk/collections';
+import { DataContextStatus } from './data-context-status';
+import { Observable, Subject } from 'rxjs';
+import { FilterContext } from '../filters/filter-context';
+import { DataContextSnapshot, IDataContext } from './data-context';
+import { SortContext } from '../sort-context';
+import { IDataSource } from '../datasource/data-source';
+export declare abstract class DataContextBase<T> extends DataSource<T> implements IDataContext<T> {
+    private _indexFn;
+    private _localApply;
+    private _localSort;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly baselog;
+    private readonly _dataSource;
+    private readonly _filter;
+    private readonly _sort;
+    private readonly _loading;
+    private readonly _data;
+    private readonly _total;
+    private readonly _status;
+    private readonly _started;
+    private readonly _closed;
+    private readonly _primaryIndex;
+    private readonly _reloadQueue;
+    protected readonly unsubscribe$: Subject<void>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    protected constructor(dataSource: IDataSource<T>, _indexFn: ((item: T) => any), _localApply: ((data: T[]) => T[]), _localSort: ((data: T[], sorts: Sort[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Public API Material DC                                                  *
+     *                                                                         *
+     **************************************************************************/
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(collectionViewer: CollectionViewer): void;
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataSource(): IDataSource<T>;
+    get snapshot(): DataContextSnapshot<T>;
+    get total(): Observable<number | undefined>;
+    get totalSnapshot(): number | undefined;
+    get sort(): SortContext;
+    get filter(): FilterContext;
+    get loading(): Observable<boolean>;
+    get loadingSnapshot(): boolean;
+    get data(): Observable<T[]>;
+    get dataSnapshot(): T[];
+    get status(): Observable<DataContextStatus>;
+    get statusSnapshot(): DataContextStatus;
+    get isEmpty(): boolean;
+    get isStarted(): boolean;
+    get isStarted$(): Observable<boolean>;
+    get isClosed(): boolean;
+    protected get started(): boolean;
+    protected set started(started: boolean);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    start(sorts?: Sort[], filters?: Filter[]): Observable<any>;
+    reload(): void;
+    findByIndex(key: any): T | undefined;
+    /**
+     * Closes this DataContext and cleans up all used resources.
+     */
+    close(): void;
+    refresh(): void;
+    /***************************************************************************
+     *                                                                         *
+     * Protected methods                                                       *
+     *                                                                         *
+     **************************************************************************/
+    protected reloadNow(): Observable<any>;
+    /**
+     * Append the given rows to to existing ones.
+     */
+    protected appendData(additionalData: T[]): void;
+    /**
+     * Replaces the existing data with the new set.
+     * @param newData The new data set.
+     * @param alreadyIndexed The rows will be indexed unless they already have been.
+     */
+    protected setData(newData: T[], alreadyIndexed?: boolean): void;
+    protected setTotal(total: number | undefined): void;
+    /**
+     * Clears the current data-context cached data.
+     * State such as current sorting and filtersSnapshot are kept.
+     */
+    protected clearAll(silent?: boolean): void;
+    protected updateIndex(): void;
+    /**
+     * Indexes the given item by key if there is an index function defined.
+     */
+    protected indexItem(item: T): void;
+    /**
+     * Indexes all the given items by key if there is an index function defined.
+     */
+    protected indexAll(items: T[]): void;
+    protected getItemKey(item: T): any;
+    /***************************************************************************
+     *                                                                         *
+     * Event handler                                                           *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Occurs when the sort has changed.
+     */
+    protected onSortsChanged(sorts: Sort[]): void;
+    /**
+     * Occurs when the filter has changed.
+     */
+    protected onFiltersChanged(filters: Filter[]): void;
+    protected onError(err: any): void;
+    protected onIdle(): void;
+    protected onLoading(): void;
+    protected onStatus(status: DataContextStatus): void;
+    /***************************************************************************
+     *                                                                         *
+     * Abstract methods                                                        *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Subclasses must implement this method and
+     * reload the currently held data.
+     * If possible, the current view state should be kept.
+     *
+     * @returns The reload job.
+     */
+    protected abstract reloadInternal(): Observable<any>;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private clearIndex;
+}

package/lib/common/data/data-context/data-context-builder.d.ts

@@ -0,0 +1,142 @@
+import { Sort } from '../sort';
+import { IDataContext, IDataContextActivePage, IDataContextContinuable } from './data-context';
+import { IContinuableDataSource, IDataSource, IListDataSource, IPagedDataSource } from '../datasource/data-source';
+import { AutoStartSpec } from './data-context-auto-starter';
+/**
+ * Provides the ability to build a IDataContext<T>.
+ */
+export declare class DataContextBuilder<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private _indexFn?;
+    private _localApply?;
+    private _localSort?;
+    private _skipLocalSort;
+    private _pageSize;
+    private _reloadOnLocalChanges;
+    private _activePaged;
+    private _autoStartSpec?;
+    /***************************************************************************
+     *                                                                         *
+     * Static                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Creates a new DataContextBuilder.
+     * @returns A new DataContextBuilder for the given data type.
+     */
+    static start<T>(): DataContextBuilder<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor();
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Optional index function where each element will be indexed by.
+     * If you have configured this, you can use the findByIndex(key) on the data-context.
+     */
+    indexBy(indexFn?: ((item: T) => any)): this;
+    /**
+     * The desired size of a page/chunk when loading data.
+     * Note that continuable apis might just take this as a wish or even completely ignore this param.
+     */
+    pageSize(size: number): this;
+    /**
+     * Sort the data context locally.
+     *
+     * Note that this might be a costly operation when there are a lot of elements present.
+     * Prefer server side sorting if possible.
+     */
+    localSort(localSort?: (data: T[], sorts: Sort[]) => T[]): this;
+    /**
+     * Enable active paging (in contrast to the infinite load) in the data context.
+     * Only supported if the underlying datasource supports pagination.
+     */
+    activePaged(): this;
+    /**
+     * For each element which is added to the datacontext, apply the given function.
+     */
+    localApply(localApply: ((data: T[]) => T[])): this;
+    /**
+     * On a local change event, automatically reload data in the data-context.
+     * This means whenever there was an modify operation on the rest client,
+     * such as Update, Delete or Create, the data will be reloaded.
+     */
+    reloadOnLocalChanges(): this;
+    autoStartAsap(sort?: Sort[]): this;
+    autoStartOnFilters(filters: Array<string[]>, sort?: Sort[]): this;
+    autoStartOnFiltersAll(filters: string[], sort?: Sort[]): this;
+    autoStartOnFiltersAny(filters: string[], sort?: Sort[]): this;
+    autoStartOn(spec: AutoStartSpec): this;
+    /***************************************************************************
+     *                                                                         *
+     * DataSource Builder                                                      *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Build a new DataContext from the given DataSource.
+     *
+     * Common DataSources are RestClient, LocalListDataSource and DelegateDataSource.
+     *
+     * @param ds
+     */
+    build(ds: IDataSource<T>): IDataContext<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Local Data Builder                                                      *
+     *                                                                         *
+     **************************************************************************/
+    buildLocal(items: T[], idProperty?: string): IDataContext<T>;
+    buildLocalActivePaged(data: T[], idProperty?: string): IDataContextActivePage<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Empty Data Builder                                                      *
+     *                                                                         *
+     **************************************************************************/
+    buildEmpty(): IDataContext<T>;
+    buildEmptyContinuable(): IDataContextContinuable<T>;
+    buildEmptyActivePaged(): IDataContextActivePage<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Legacy Client Builder                                                   *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * @deprecated Switch to build(dataSource)
+     */
+    buildClient(dataSource: IListDataSource<T>): IDataContext<T>;
+    /**
+     * @deprecated Switch to build(dataSource)
+     */
+    buildPagedClient(dataSource: IPagedDataSource<T>): IDataContextContinuable<T>;
+    /**
+     * @deprecated Switch to build(dataSource)
+     */
+    buildContinuationTokenClient(dataSource: IContinuableDataSource<T>): IDataContextContinuable<T>;
+    /**
+     * @deprecated Switch to .activePaged().build(dataSource)
+     */
+    buildActivePagedClient(dataSource: IPagedDataSource<T>): IDataContextActivePage<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private buildFromSource;
+    private fromListSource;
+    private fromPageSource;
+    private fromContinuationSource;
+    private fromActivePageSource;
+    private setupDataContextAutoReload;
+    private setupDataContextAutoStart;
+}

package/lib/common/data/data-context/data-context-continuable-base.d.ts

@@ -0,0 +1,43 @@
+import { DataContextBase } from './data-context-base';
+import { Sort } from '../sort';
+import { Filter } from '../filters/filter';
+import { Observable } from 'rxjs';
+import { IDataContextContinuable } from './data-context';
+import { IDataSource } from '../datasource/data-source';
+/**
+ * Extends a simple flat list data-context with infinite-scroll pagination support.
+ *
+ */
+export declare abstract class DataContextContinuableBase<T> extends DataContextBase<T> implements IDataContextContinuable<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly cblogger;
+    private _chunkSize;
+    /***************************************************************************
+     *                                                                         *
+     * Constructors                                                            *
+     *                                                                         *
+     **************************************************************************/
+    protected constructor(dataSource: IDataSource<T>, chunkSize: number, indexFn: ((item: T) => any), localApply: ((data: T[]) => T[]), localSort: ((data: T[], sorts: Sort[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    loadAll(sorts?: Sort[], filters?: Filter[]): void;
+    get chunkSize(): number;
+    set chunkSize(size: number);
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    protected onChunkSizeChanged(newSize: number): void;
+    private loadAllRec;
+    abstract loadMore(): Observable<any>;
+    abstract get hasMoreDataSnapshot(): boolean;
+    abstract get hasMoreData(): Observable<boolean>;
+}