@elderbyte/ngx-starter 19.19.0 → 20.0.0-beta.2

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

@@ -1,177 +0,0 @@
-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                                                              *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * An auto generated id of this DataContext instance.
-     * Mostly for debugging purposes.
-     */
-    readonly id: string;
-    /**
-     * 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 context 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(reason?: string): Observable<any>;
-    /**
-     * 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 a custom index key.
-     * Requires that custom index functionality is enabled.
-     *
-     * For id based lookup, refer to findById().
-     *
-     * @param key
-     */
-    findByIndex(key: any): T | undefined;
-    /**
-     * Lookup an entity by its id. This method is guaranteed to be backed by a fast index.
-     * @param id The Entity Id.
-     */
-    findById(id: any): T | undefined;
-    /**
-     * Update the given entities in this data-context
-     */
-    update(entities: T[]): void;
-}
-/**
- * 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;
-    /**
-     * Set the desired chunk size
-     */
-    set chunkSize(size: number | undefined);
-    get chunkSize(): number;
-    get chunkSize$(): Observable<number | undefined>;
-}
-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/indexed-entities.d.ts

@@ -1,72 +0,0 @@
-import { Observable } from 'rxjs';
-import { Sort } from '../sort';
-import { SortContext } from '../sort-context';
-export declare class IndexedEntities<T, TId = any> {
-    private readonly idFn;
-    private readonly localSortFn;
-    private readonly sortContext;
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly log;
-    private readonly _entities$;
-    private readonly _idToArrayIndex;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(idFn: (e: T) => TId, localSortFn: ((data: T[], sorts: Sort[]) => T[]) | undefined, sortContext: SortContext);
-    /***************************************************************************
-     *                                                                         *
-     * Properties                                                              *
-     *                                                                         *
-     **************************************************************************/
-    get entities$(): Observable<T[]>;
-    get entitiesSnapshot(): T[];
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Replaces all existing entities with the new ones.
-     * The index is rebuilt. O(n)
-     */
-    replaceAll(newEntities?: T[]): void;
-    /**
-     * Keeps all existing entities, but replaces those which are updated with the new data.
-     * Provided updated entities which are currently not in this index are ignored.
-     * @param updated
-     */
-    updateSome(updated: T[]): void;
-    append(append: T[]): void;
-    /**
-     * Appends the given entities to this index.
-     * The new appended entities are included in the index.
-     * O(n) where n = number of appended entities
-     * @param inserted
-     * @param offset
-     */
-    insert(inserted: T[], offset: number): void;
-    /**
-     * Lookup an entity by its id.
-     * This will use an index O(1)
-     * @param id
-     */
-    getById(id: TId): T | undefined;
-    notify(): void;
-    destroy(): void;
-    /***************************************************************************
-     *                                                                         *
-     * Private methods                                                         *
-     *                                                                         *
-     **************************************************************************/
-    private rebuildIndex;
-    private reIndexFrom;
-    private indexById;
-    private getItemId;
-    private setEntities;
-}

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

@@ -1,65 +0,0 @@
-import { MatPaginator } from '@angular/material/paginator';
-import { MatSort } from '@angular/material/sort';
-import { IDataContext } from './data-context';
-import { Observable } from 'rxjs';
-import { ElderContinuatorComponent } from '../../../components/data-view/common/elder-continuator/elder-continuator.component';
-export declare class MatTableDataContextBindingBuilder {
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly logger;
-    private _dataContext$;
-    private _sorts$;
-    private _matPaginator$;
-    private _continuator$;
-    /***************************************************************************
-     *                                                                         *
-     * 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;
-    withContinuator(continuator$: Observable<ElderContinuatorComponent>): this;
-    bindUntil(destroy$: Observable<any>): MatTableDataContextBinding;
-}
-export declare class MatTableDataContextBinding {
-    private readonly _dataContext$;
-    private readonly _matSorts$;
-    private readonly _matPaginator$;
-    private readonly _continuator$;
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly logger;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(_dataContext$: Observable<IDataContext<any>>, _matSorts$: Observable<MatSort[]> | null, _matPaginator$: Observable<MatPaginator> | null, _continuator$: Observable<ElderContinuatorComponent> | null, destroy$: Observable<any>);
-    /***************************************************************************
-     *                                                                         *
-     * Private methods                                                         *
-     *                                                                         *
-     **************************************************************************/
-    private subscribeUntil;
-    private bindDataContextToMatSortsUntil;
-    private updateMatSorts;
-    private updateMatSort;
-    private bindMatSortsToDataContextUntil;
-    private bindPaginatorUntil;
-    private bindContinuatorUntil;
-    private toMatDirection;
-    private fromMatDirection;
-}

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

@@ -1,14 +0,0 @@
-export * from './indexed-entities';
-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-event-binding';
-export * from './data-context-builder';

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

@@ -1,47 +0,0 @@
-import { LocalListDataSource, LocalDataSortFn, LocalDataFilterFn } from '../local/local-list-data-source';
-import { IDataSource } from '../data-source';
-import { DataSourceChangeEvent } from '../data-source-change-event';
-import { Observable } from 'rxjs';
-export declare class CuratedDataSource<TEntity, TId = any> implements IDataSource<TEntity> {
-    readonly originalSource: IDataSource<TEntity>;
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    protected readonly curatedData: LocalListDataSource<TEntity>;
-    private readonly useCuratedData$;
-    private readonly ready$;
-    private readonly _dataChanged;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(originalSource: IDataSource<TEntity>, localSort?: LocalDataSortFn<TEntity>, localFilter?: LocalDataFilterFn<TEntity>);
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    useCuratedData(data: TEntity[]): void;
-    useNonCuratedData(): void;
-    /***************************************************************************
-     *                                                                         *
-     * IDataSource API                                                         *
-     *                                                                         *
-     **************************************************************************/
-    get dataChanged(): Observable<DataSourceChangeEvent<TEntity, any>>;
-    findById(id: any): Observable<TEntity>;
-    findByIds(ids: TId[]): Observable<TEntity[]>;
-    getId(entity: TEntity): TId;
-    /***************************************************************************
-     *                                                                         *
-     * Private methods                                                         *
-     *                                                                         *
-     **************************************************************************/
-    protected get readyUseCurated$(): Observable<boolean>;
-    private buildDataChanged;
-    private findByIdsFirstCuratedThenOriginal;
-    private findAvailableCuratedByIds;
-}

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

@@ -1,27 +0,0 @@
-import { Observable } from 'rxjs';
-import { Sort } from '../../../data/sort';
-import { Filter } from '../../../data/filters/filter';
-import { LocalDataSortFn, LocalDataFilterFn } from '../local/local-list-data-source';
-import { IListDataSource } from '../data-source';
-import { CuratedDataSource } from './curated-data-source';
-/**
- * Wraps a standard IListDataSource, and provides the ability to overwrite
- * the returned data with custom curated data.
- *
- * You need to either invoke useCuratedData(..) or useNonCuratedData() to make data available.
- */
-export declare class CuratedListDataSource<TEntity> extends CuratedDataSource<TEntity> implements IListDataSource<TEntity> {
-    private listDataSource;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(listDataSource: IListDataSource<TEntity>, localSort?: LocalDataSortFn<TEntity>, localFilter?: LocalDataFilterFn<TEntity>);
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                         *
-     *                                                                         *
-     **************************************************************************/
-    findAllFiltered(filters?: Filter[], sorts?: Sort[]): Observable<Array<TEntity>>;
-}

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

@@ -1,33 +0,0 @@
-import { Observable } from 'rxjs';
-import { Filter } from '../../../data/filters/filter';
-import { LocalDataSortFn, LocalDataFilterFn } from '../local/local-list-data-source';
-import { IPagedDataSource } from '../data-source';
-import { CuratedDataSource } from './curated-data-source';
-import { Page, Pageable } from '../../../data/page';
-/**
- * Wraps a standard IPagedDataSource, and provides the ability to overwrite
- * the returned data with custom curated data.
- *
- * You need to either invoke useCuratedData(..) or useNonCuratedData() to make data available.
- */
-export declare class CuratedPagedDataSource<TEntity> extends CuratedDataSource<TEntity> implements IPagedDataSource<TEntity> {
-    private pagedDataSource;
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly curatedDataPaged;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(pagedDataSource: IPagedDataSource<TEntity>, localSort?: LocalDataSortFn<TEntity>, localFilter?: LocalDataFilterFn<TEntity>);
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                         *
-     *                                                                         *
-     **************************************************************************/
-    findAllPaged(pageable: Pageable, filters?: Filter[]): Observable<Page<TEntity>>;
-}

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

@@ -1,39 +0,0 @@
-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-base.d.ts

@@ -1,39 +0,0 @@
-import { IDataSource } from './data-source';
-import { DataSourceChangeEvent } from './data-source-change-event';
-import { Observable } from 'rxjs';
-import { IdExtractor } from './entity-id-util';
-export declare abstract class DataSourceBase<T> implements IDataSource<T> {
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly dataChangeEvents$;
-    private readonly extractIdFn;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    protected constructor(propertyOrIdExtractor: string | IdExtractor<T>);
-    /***************************************************************************
-     *                                                                         *
-     * Properties                                                              *
-     *                                                                         *
-     **************************************************************************/
-    get dataChanged(): Observable<DataSourceChangeEvent<T>>;
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    publishChangeEvent(e: DataSourceChangeEvent<T>): void;
-    getId(entity: T): any;
-    /***************************************************************************
-     *                                                                         *
-     * Abstract methods                                                        *
-     *                                                                         *
-     **************************************************************************/
-    abstract findById(id: any): Observable<T>;
-    abstract findByIds(ids: any[]): Observable<T[]>;
-}

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

@@ -1,22 +0,0 @@
-import { DeepPartialPatch } from './patch/deep-partial-patcher';
-export declare class DataSourceEntityPatch<T, Id = any> {
-    entityId: Id;
-    patch: DeepPartialPatch<T>;
-    constructor(entityId: Id, patch: DeepPartialPatch<T>);
-}
-/**
- * Notifies about changes in a DataSource.
- */
-export declare class DataSourceChangeEvent<T, TId = any> {
-    readonly deletedIds: TId[];
-    readonly modified: T[];
-    readonly created: T[];
-    readonly patches: DataSourceEntityPatch<T>[];
-    static unknownChanges<T, TId = any>(): DataSourceChangeEvent<T>;
-    static deleted<TId>(ids: TId[]): DataSourceChangeEvent<any, TId>;
-    static modified<T, TId = any>(modified: T[]): DataSourceChangeEvent<T>;
-    static created<T, TId = any>(created: T[]): DataSourceChangeEvent<T>;
-    static patched<T, TId = any>(patches: DataSourceEntityPatch<T, TId>[]): DataSourceChangeEvent<T>;
-    readonly unknownChanges: boolean;
-    constructor(deletedIds: TId[], modified: T[], created: T[], patches: DataSourceEntityPatch<T>[]);
-}

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

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