@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.1

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

@@ -0,0 +1,58 @@
+import { Observable } from 'rxjs';
+import { DataContextContinuableBase } from './data-context-continuable-base';
+import { Sort } from '../sort';
+import { IPagedDataSource } from '../datasource/data-source';
+/**
+ * Extends a simple flat list data-context with infinite-scroll pagination support.
+ *
+ */
+export declare class DataContextContinuablePaged<T> extends DataContextContinuableBase<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private _pageCache;
+    private _latestPage;
+    private readonly _hasMoreData;
+    /***************************************************************************
+     *                                                                         *
+     * Constructors                                                            *
+     *                                                                         *
+     **************************************************************************/
+    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>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Load the next chunk of data.
+     * Useful for infinite scroll like data flows.
+     *
+     */
+    loadMore(): Observable<any>;
+    get hasMoreData(): Observable<boolean>;
+    get hasMoreDataSnapshot(): boolean;
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private checkHasMoreData;
+    protected onChunkSizeChanged(newSize: number): void;
+    protected reloadInternal(): Observable<any>;
+    protected clearAll(silent?: boolean): void;
+    private fetchPage;
+    /**
+     * Load the data from the given page into the current data context
+     */
+    private populatePageData;
+}

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

@@ -0,0 +1,48 @@
+import { DataContextContinuableBase } from './data-context-continuable-base';
+import { Observable } from 'rxjs';
+import { Sort } from '../sort';
+import { IContinuableDataSource } from '../datasource/data-source';
+export declare class DataContextContinuableToken<T> extends DataContextContinuableBase<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private readonly _hasMoreData;
+    private readonly _chunkCache;
+    private _expectedChunkToken?;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataSource: IContinuableDataSource<T>, chunkSize: number, indexFn: ((item: T) => any), localApply: ((data: T[]) => T[]), localSort: ((data: T[], sorts: Sort[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataSource(): IContinuableDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get hasMoreDataSnapshot(): boolean;
+    get hasMoreData(): Observable<boolean>;
+    loadMore(): Observable<any>;
+    /***************************************************************************
+     *                                                                         *
+     * Protect API                                                             *
+     *                                                                         *
+     **************************************************************************/
+    protected clearAll(silent?: boolean): void;
+    protected reloadInternal(): Observable<any>;
+    private fetchNextChunk;
+    /**
+     * Load the data from the given page into the current data context
+     */
+    private populateChunkData;
+    private areTokenEqual;
+}

package/lib/common/data/data-context/data-context-life-cycle-binding.d.ts

@@ -0,0 +1,33 @@
+import { Subscription, Unsubscribable } from 'rxjs';
+import { IDataContext } from './data-context';
+/**
+ * Allows making any kind of subscription which will be automatically unsubscribed
+ * upon data context closing/cleanup.
+ */
+export declare abstract class DataContextLifeCycleBinding implements Unsubscribable {
+    protected readonly _dataContext: IDataContext<any>;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    protected _subscription: Subscription;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    protected constructor(_dataContext: IDataContext<any>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    unsubscribe(): void;
+    /***************************************************************************
+     *                                                                         *
+     * Protected                                                               *
+     *                                                                         *
+     **************************************************************************/
+    protected abstract subscribe(): void;
+}

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

@@ -0,0 +1,30 @@
+import { DataContextBase } from './data-context-base';
+import { Sort } from '../sort';
+import { Observable } from 'rxjs';
+import { IListDataSource } from '../datasource/data-source';
+export declare class DataContextSimple<T> extends DataContextBase<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly log;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataSource: IListDataSource<T>, indexFn: ((item: T) => any), localApply: ((data: T[]) => T[]), localSort: ((data: T[], sorts: Sort[]) => T[]));
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataSource(): IListDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    protected reloadInternal(): Observable<any>;
+}

package/lib/common/data/data-context/data-context-source-auto-reloader.d.ts

@@ -0,0 +1,8 @@
+import { IDataContext } from './data-context';
+import { IDataSource } from '../datasource/data-source';
+import { DataContextLifeCycleBinding } from './data-context-life-cycle-binding';
+export declare class DataContextSourceAutoReloader extends DataContextLifeCycleBinding {
+    private readonly dataApi;
+    constructor(dataContext: IDataContext<any>, dataApi: IDataSource<any>);
+    protected subscribe(): void;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Represents the status of a data-context
+ */
+export declare class DataContextStatus {
+    private readonly _error;
+    private readonly _loading;
+    /***************************************************************************
+     *                                                                         *
+     * Static builders                                                         *
+     *                                                                         *
+     **************************************************************************/
+    static idle(): DataContextStatus;
+    static error(error: any): DataContextStatus;
+    static loading(): DataContextStatus;
+    /***************************************************************************
+     *                                                                         *
+     * Constructors                                                            *
+     *                                                                         *
+     **************************************************************************/
+    constructor(_error: any, _loading?: boolean);
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get idle(): boolean;
+    get loading(): boolean;
+    get error(): any;
+    get hasError(): boolean;
+}

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

@@ -0,0 +1,154 @@
+import { DataContextStatus } from './data-context-status';
+import { Observable } from 'rxjs';
+import { Sort } from '../sort';
+import { Filter } from '../filters/filter';
+import { FilterContext } from '../filters/filter-context';
+import { PageRequest } from '../page';
+import { SortContext } from '../sort-context';
+import { IDataSource } from '../datasource/data-source';
+export declare class DataContextSnapshot<T> {
+    readonly data: T[];
+    readonly isEmpty: boolean;
+    readonly isLoading: boolean;
+    readonly total: number | undefined;
+    readonly status: DataContextStatus;
+    constructor(data: T[], isEmpty: boolean, isLoading: boolean, total: number | undefined, status: DataContextStatus);
+}
+/**
+ * Manages a set of data (rows) which are to be displayed in a UI Component.
+ *
+ */
+export interface IDataContext<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Gets the underlying DataSource of this DataContext.
+     */
+    readonly dataSource: IDataSource<T>;
+    /**
+     * Gets a snapshot of the current state in this data-context
+     */
+    readonly snapshot: DataContextSnapshot<T>;
+    /**
+     * Observable which emits the current data over time.
+     */
+    readonly data: Observable<T[]>;
+    /**
+     * Indicates if the context currently holds no data
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Indicates if the context has been started.
+     */
+    readonly isStarted: boolean;
+    /**
+     * Indicates if the context has been started.
+     */
+    readonly isStarted$: Observable<boolean>;
+    /**
+     * Indicates if the context has been closed.
+     * Depending on the implementation, restarting might not be possible.
+     */
+    readonly isClosed: boolean;
+    /**
+     * Indicates if data is loading over time
+     */
+    readonly loading: Observable<boolean>;
+    /**
+     * The total count of all elements over time
+     * (I.e. the expected count when the data contex is completed)
+     */
+    readonly total: Observable<number | undefined>;
+    /**
+     * Observable which emits when the status changes (i.e. error)
+     */
+    readonly status: Observable<DataContextStatus>;
+    /**
+     * Gets the sort context. Changes in this context are reflected by the data-context.
+     */
+    readonly sort: SortContext;
+    /**
+     * Gets the filter context. Changes in this context are reflected by the data-context.
+     */
+    readonly filter: FilterContext;
+    /***************************************************************************
+     *                                                                         *
+     * API                                                                     *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Starts populating data context by loading first
+     * batch of data.
+     */
+    start(sorts?: Sort[], filters?: Filter[]): Observable<any>;
+    /**
+     * Requests a reload of the current data / chunk.
+     * Attempts to keep the current position.
+     */
+    reload(): void;
+    /**
+     * Refresh the data view from the local data model. (Does not request new data from the server)
+     * Useful if the data model has changes that need to be reflected in the UI.
+     */
+    refresh(): void;
+    /**
+     * Closes the data-context and cleans up resources
+     */
+    close(): void;
+    /**
+     * Returns the item by the given index key.
+     * Requires that index functionality is enabled.
+     * @param key
+     */
+    findByIndex(key: any): T | undefined;
+}
+/**
+ * Represents a data-context which backs a infinite like data stream
+ * where more data will be loaded and added to the backing rows.
+ */
+export interface IDataContextContinuable<T> extends IDataContext<T> {
+    /**
+     * Returns true if this data-context can load more data
+     */
+    readonly hasMoreDataSnapshot: boolean;
+    /**
+     * Returns true if this data-context can load more data over time
+     */
+    readonly hasMoreData: Observable<boolean>;
+    /**
+     * Loads more data if any available.
+     * E.g. next page.
+     *
+     */
+    loadMore(): Observable<any>;
+    /**
+     * Loads all available data. In case of
+     * paged context loads page by page until finished.
+     */
+    loadAll(sorts?: Sort[], filters?: Filter[]): void;
+}
+export interface IDataContextActivePage<T> extends IDataContext<T> {
+    /**
+     * Gets the active page over time
+     */
+    readonly page: Observable<PageRequest>;
+    /**
+     * Gets the current active page
+     */
+    readonly pageSnapshot: PageRequest;
+    /**
+     * Sets the active page
+     */
+    setActivePage(page: PageRequest): void;
+}
+/***************************************************************************
+ *                                                                         *
+ * Type Predicates                                                         *
+ *                                                                         *
+ **************************************************************************/
+export declare function isDataContext(object: any): object is IDataContext<any>;
+export declare function isContinuableDataContext(object: IDataContext<any>): object is IDataContextContinuable<any>;
+export declare function isActivePagedDataContext(object: IDataContext<any>): object is IDataContextActivePage<any>;

package/lib/common/data/data-context/mat-table-data-context-binding.d.ts

@@ -0,0 +1,60 @@
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { IDataContext } from './data-context';
+import { Observable } from 'rxjs';
+export declare class MatTableDataContextBindingBuilder {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    private _dataContext$;
+    private _sorts$;
+    private _matPaginator$;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    static start(dataContext$: Observable<IDataContext<any>>): MatTableDataContextBindingBuilder;
+    constructor(dataContext$: Observable<IDataContext<any>>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    withSorts(sorts$: Observable<MatSort[]>): this;
+    withPaginator(paginator$: Observable<MatPaginator>): this;
+    bindUntil(destroy$: Observable<any>): MatTableDataContextBinding;
+}
+export declare class MatTableDataContextBinding {
+    private readonly _dataContext$;
+    private readonly _matSorts$;
+    private readonly _matPaginator$;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly logger;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(_dataContext$: Observable<IDataContext<any>>, _matSorts$: Observable<MatSort[]> | null, _matPaginator$: Observable<MatPaginator> | null, destroy$: Observable<any>);
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private subscribeUntil;
+    private bindDataContextToMatSortsUntil;
+    private updateMatSorts;
+    private updateMatSort;
+    private bindMatSortsToDataContextUntil;
+    private bindPaginatorUntil;
+    private toMatDirection;
+    private fromMatDirection;
+}

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

@@ -0,0 +1,13 @@
+export * from './data-context-status';
+export * from './data-context';
+export * from './data-context-base';
+export * from './data-context-simple';
+export * from './data-context-continuable-base';
+export * from './data-context-continuable-paged';
+export * from './data-context-continuable-token';
+export * from './data-context-active-page';
+export * from './mat-table-data-context-binding';
+export * from './data-context-life-cycle-binding';
+export * from './data-context-auto-starter';
+export * from './data-context-source-auto-reloader';
+export * from './data-context-builder';

package/lib/common/data/datasource/data-source-adapter.d.ts

@@ -0,0 +1,39 @@
+import { IDataSource } from './data-source';
+import { Observable } from 'rxjs';
+import { Filter } from '../filters/filter';
+import { Sort } from '../sort';
+export declare class DataSourceAdapter<T> {
+    private readonly dataSource;
+    /***************************************************************************
+     *                                                                         *
+     * Static Builder                                                          *
+     *                                                                         *
+     **************************************************************************/
+    static from<T>(dataSource: IDataSource<T>): DataSourceAdapter<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(dataSource: IDataSource<T>);
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Returns the first item which matches the given filter / sort
+     * @param filters
+     * @param sorts
+     */
+    findFirst(filters: Filter[], sorts?: Sort[]): Observable<T>;
+    /**
+     * Find all items which match the given filters.
+     */
+    findAll(filters: Filter[], sorts?: Sort[], limit?: number): Observable<T[]>;
+}

package/lib/common/data/datasource/data-source-processor.d.ts

@@ -0,0 +1,106 @@
+import { IContinuableDataSource, IDataSource, IListDataSource, IPagedDataSource } from './data-source';
+import { Page } from '../page';
+import { Filter } from '../filters/filter';
+import { ContinuableListing } from '../continuable-listing';
+import { Sort } from '../sort';
+import { Observable } from 'rxjs/internal/Observable';
+export declare enum ProcessState {
+    INIT = "INIT",
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    ERROR = "ERROR"
+}
+export declare class ProcessIterationContext<T> {
+    readonly state: ProcessState;
+    readonly items?: T[];
+    readonly page?: Page<T>;
+    readonly continuable?: ContinuableListing<T>;
+    static init<T>(): ProcessIterationContext<T>;
+    static processingList<T>(list: T[]): ProcessIterationContext<T>;
+    static processingPage<T>(currentPage: Page<T>): ProcessIterationContext<T>;
+    static processingContinuable<T>(currentChunk: ContinuableListing<T>): ProcessIterationContext<T>;
+    static completed<T>(): ProcessIterationContext<T>;
+    static error<T>(): ProcessIterationContext<T>;
+    constructor(state: ProcessState, items?: T[], page?: Page<T>, continuable?: ContinuableListing<T>);
+}
+export declare class DataSourceProcessor<T> {
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    private readonly log;
+    private readonly _dataSource;
+    private readonly _chunkSize;
+    private readonly _process$;
+    /***************************************************************************
+     *                                                                         *
+     * Static                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    static start<T>(dataSource: IDataSource<T>, chunkSize?: number): DataSourceProcessor<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    protected constructor(dataSource: IDataSource<T>, chunkSize?: number);
+    /***************************************************************************
+     *                                                                         *
+     * Properties                                                              *
+     *                                                                         *
+     **************************************************************************/
+    get dataSource(): IDataSource<T>;
+    protected get listDataSource(): IListDataSource<T>;
+    protected get pagedDataSource(): IPagedDataSource<T>;
+    protected get continuableDataSource(): IContinuableDataSource<T>;
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    /**
+     * Allows to iterative load and process the contents of the
+     * data source in scope.
+     *
+     * @param processFn to iterative execute upon each item of each iteration
+     * @param filters to filter the data source
+     * @param sorts to sort the data source
+     */
+    process$(processFn: (dataChunk: T[]) => any, filters: Filter[], sorts: Sort[]): Observable<ProcessIterationContext<T>>;
+    /***************************************************************************
+     *                                                                         *
+     * Loading                                                                 *
+     *                                                                         *
+     **************************************************************************/
+    private loadNext;
+    /***************************************************************************
+     *                                                                         *
+     * List                                                                    *
+     *                                                                         *
+     **************************************************************************/
+    private loadList;
+    private listIteration;
+    /***************************************************************************
+     *                                                                         *
+     * Paged                                                                   *
+     *                                                                         *
+     **************************************************************************/
+    private loadNextPage;
+    private pageIteration;
+    private pageIterationState;
+    /***************************************************************************
+     *                                                                         *
+     * Continuable                                                             *
+     *                                                                         *
+     **************************************************************************/
+    private loadNextContinuable;
+    private continuableIteration;
+    private continuableIterationState;
+    /***************************************************************************
+     *                                                                         *
+     * Private Methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    private notCompleted;
+}

package/lib/common/data/datasource/data-source.d.ts

@@ -0,0 +1,58 @@
+import { Observable } from 'rxjs';
+import { Sort } from '../sort';
+import { Filter } from '../filters/filter';
+import { Page, Pageable } from '../page';
+import { TokenChunkRequest } from '../token-chunk-request';
+import { ContinuableListing } from '../continuable-listing';
+/***************************************************************************
+ *                                                                         *
+ * Data Fetcher APIs                                                       *
+ *                                                                         *
+ **************************************************************************/
+export interface IListFetcher<T> {
+    findAllFiltered(filters?: Filter[], sorts?: Sort[]): Observable<Array<T>>;
+}
+export interface IPageFetcher<T> {
+    findAllPaged(pageable: Pageable, filters?: Filter[]): Observable<Page<T>>;
+}
+export interface IContinuationFetcher<T> {
+    findAllContinuable(tokenChunkRequest: TokenChunkRequest): Observable<ContinuableListing<T>>;
+}
+/***************************************************************************
+ *                                                                         *
+ * Data Accessor APIs                                                      *
+ *                                                                         *
+ **************************************************************************/
+export interface IDataSource<T> {
+    /**
+     * Notifies that this data source has modified elements.
+     */
+    readonly dataChanged: Observable<any>;
+    /**
+     * Return the entity with the given Id.
+     */
+    findById(id: any): Observable<T>;
+    /**
+     * Return the entity with the given Id.
+     */
+    findByIds(ids: any[]): Observable<T[]>;
+    /**
+     * Get the Id value of the given entity
+     */
+    getId(entity: T): any;
+}
+export interface IListDataSource<T> extends IListFetcher<T>, IDataSource<T> {
+}
+export interface IPagedDataSource<T> extends IPageFetcher<T>, IDataSource<T> {
+}
+export interface IContinuableDataSource<T> extends IContinuationFetcher<T>, IDataSource<T> {
+}
+/***************************************************************************
+ *                                                                         *
+ * Type Predicates                                                         *
+ *                                                                         *
+ **************************************************************************/
+export declare function isDataSource(object: any): object is IDataSource<any>;
+export declare function isListDataSource(object: IDataSource<any>): object is IListDataSource<any>;
+export declare function isPagedDataSource(object: IDataSource<any>): object is IPagedDataSource<any>;
+export declare function isContinuableDataSource(object: IDataSource<any>): object is IContinuableDataSource<any>;

package/lib/common/data/datasource/entity-id-util.d.ts

@@ -0,0 +1,3 @@
+export declare class EntityIdUtil {
+    static getId<T>(entity: T, idProperty: string): any;
+}