@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.0

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

@@ -1,108 +0,0 @@
-
-import {IDataContext} from './data-context';
-import {RequiredFilterEvaluator} from '../required-filter-evaluator';
-import {DataContextLifeCycleBinding} from './data-context-life-cycle-binding';
-import {Observable} from 'rxjs';
-import {filter, map} from 'rxjs/operators';
-import {LoggerFactory} from '@elderbyte/ts-logger';
-import {Sort} from '../sort';
-
-export class AutoStartSpec {
-
-  public static asap(sort?: Sort[]): AutoStartSpec {
-    return new AutoStartSpec(null, sort);
-  }
-
-  public static requireFiltersAll(filters: string[], sort?: Sort[]): AutoStartSpec {
-    return AutoStartSpec.requireFilters([filters], sort);
-  }
-
-  public static requireFiltersAny(filters: string[], sort?: Sort[]): AutoStartSpec {
-    const separateFilterArrays = filters.map(singleFilter => [singleFilter]);
-    return AutoStartSpec.requireFilters(separateFilterArrays, sort);
-  }
-
-  public static requireFilters(filters: Array<string[]>, sort?: Sort[]): AutoStartSpec {
-    return new AutoStartSpec(filters, sort);
-  }
-
-  constructor(
-    public requiredFilters?: Array<string[]>,
-    public initialSort?: Sort[]
-  ) {
-  }
-}
-
-export class DataContextAutoStarter extends DataContextLifeCycleBinding {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private readonly logger = LoggerFactory.getLogger(this.constructor.name);
-
-  private readonly _autoStartConditionFulfilled$: Observable<boolean>;
-
-  /***************************************************************************
-   *                                                                         *
-   * Constructor                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-  constructor(
-    dataContext: IDataContext<any>,
-    private readonly _autoStartSpec: AutoStartSpec
-  ) {
-    super(dataContext);
-
-    if (_autoStartSpec == null) {
-      throw new Error('autoStartSpec must not be null!');
-    }
-
-    if (_autoStartSpec.requiredFilters) {
-      this._autoStartConditionFulfilled$ = this.buildRequiredFilterConditionObservable();
-    } else {
-      // no condition defined, try to start immediately
-      this.startDataContext();
-    }
-
-    this.subscribe();
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  protected subscribe(): void {
-    if (this._autoStartConditionFulfilled$) {
-      this._subscription = this._autoStartConditionFulfilled$.pipe(
-        filter(fulfilled => !!fulfilled)
-      ).subscribe(() => this.startDataContext());
-    }
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-  private buildRequiredFilterConditionObservable(): Observable<boolean> {
-    return new RequiredFilterEvaluator(
-      this._dataContext.filter,
-      this._autoStartSpec.requiredFilters
-    ).context$.pipe(
-      map(event => event.isValid)
-    );
-  }
-
-  private startDataContext() {
-    this.logger.debug('Auto starting data context...');
-    this._dataContext.start(this._autoStartSpec.initialSort);
-  }
-
-}

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

@@ -1,406 +0,0 @@
-import {Logger, LoggerFactory} from '@elderbyte/ts-logger';
-import {Filter} from '../filters/filter';
-import {Sort} from '../sort';
-import {CollectionViewer, DataSource} from '@angular/cdk/collections';
-import {DataContextStatus} from './data-context-status';
-import {BehaviorSubject, EMPTY, Observable, of, Subject} from 'rxjs';
-import {FilterContext} from '../filters/filter-context';
-import {DataContextSnapshot, IDataContext} from './data-context';
-import {catchError, debounceTime, filter, map, takeUntil} from 'rxjs/operators';
-import {SortContext} from '../sort-context';
-import {IDataSource} from '../datasource/data-source';
-
-export abstract class DataContextBase<T> extends DataSource<T> implements IDataContext<T> {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private readonly baselog: Logger = LoggerFactory.getLogger('DataContextBase');
-
-  private readonly _dataSource: IDataSource<T>;
-
-  private readonly _filter = new FilterContext();
-  private readonly _sort = new SortContext();
-
-  private readonly _loading: Observable<boolean>;
-
-  private readonly _data = new BehaviorSubject<T[]>([]);
-  private readonly _total = new BehaviorSubject<number | undefined>(undefined);
-  private readonly _status = new BehaviorSubject<DataContextStatus>(DataContextStatus.idle());
-
-  private readonly _started = new BehaviorSubject<boolean>(false);
-  private readonly _closed = new BehaviorSubject<boolean>(false);
-
-  private readonly _primaryIndex = new Map<any, T>();
-
-  private readonly _reloadQueue = new Subject<void>();
-
-  protected readonly unsubscribe$ = new Subject<void>();
-
-  /***************************************************************************
-   *                                                                         *
-   * Constructor                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-  protected constructor(
-    dataSource: IDataSource<T>,
-    private _indexFn: ((item: T) => any),
-    private _localApply: ((data: T[]) => T[]),
-    private _localSort: ((data: T[], sorts: Sort[]) => T[]),
-  ) {
-    super();
-
-    this._dataSource = dataSource;
-
-    this._loading = this._status.pipe(
-      map(status => status.loading)
-    );
-
-    this._filter.filters.pipe(
-      filter(() => this.started),
-      takeUntil(this.unsubscribe$)
-    ).subscribe(
-      filters => this.onFiltersChanged(filters)
-    );
-
-    this._sort.sorts.pipe(
-      filter(() => this.started),
-      takeUntil(this.unsubscribe$)
-    ).subscribe(
-      sorts => this.onSortsChanged(sorts)
-    );
-
-    this._reloadQueue.pipe(
-      filter(() => this.started),
-      debounceTime(50),
-      takeUntil(this.unsubscribe$),
-      catchError(err => {  // Dont die on errors
-        this.baselog.error('Reload queue detected error, bad!', err);
-        return EMPTY;
-      })
-    ).subscribe(() => this.reloadNow());
-    // Maybe skipMap the real requests for auto abort pending (except for continuation / paged)
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API Material DC                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  public connect(collectionViewer: CollectionViewer): Observable<T[]> {
-    return this.data;
-  }
-
-  public disconnect(collectionViewer: CollectionViewer): void {
-    // this.close(); Closing will destroy the DC
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Properties                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  public get dataSource(): IDataSource<T> {
-    return this._dataSource;
-  }
-
-  public get snapshot(): DataContextSnapshot<T> {
-    return new DataContextSnapshot(
-      this.dataSnapshot,
-      this.isEmpty,
-      this.loadingSnapshot,
-      this.totalSnapshot,
-      this.statusSnapshot
-    );
-  }
-
-
-  public get total(): Observable<number | undefined> {
-    return this._total.asObservable();
-  }
-
-  public get totalSnapshot(): number | undefined {
-    return this._total.getValue();
-  }
-
-  public get sort(): SortContext {
-    return this._sort;
-  }
-
-  public get filter(): FilterContext {
-    return this._filter;
-  }
-
-  public get loading(): Observable<boolean> {
-    return this._loading;
-  }
-
-  public get loadingSnapshot(): boolean {
-    return this.statusSnapshot?.loading;
-  }
-
-  public get data(): Observable<T[]> {
-    return this._data.asObservable();
-  }
-
-  public get dataSnapshot(): T[] {
-    return this._data.getValue();
-  }
-
-  public get status(): Observable<DataContextStatus> {
-    return this._status;
-  }
-
-  public get statusSnapshot(): DataContextStatus {
-    return this._status.getValue();
-  }
-
-  public get isEmpty(): boolean {
-    return this.dataSnapshot.length === 0;
-  }
-
-  public get isStarted(): boolean {
-    return this.started;
-  }
-
-  public get isStarted$(): Observable<boolean> {
-    return this._started.asObservable();
-  }
-
-  public get isClosed(): boolean {
-    return this._closed.getValue();
-  }
-
-  protected get started(): boolean {
-    return this._started.getValue();
-  }
-
-  protected set started(started: boolean) {
-    this._started.next(started);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  public start(sorts?: Sort[], filters?: Filter[]): Observable<any> {
-
-    if (this.isClosed) {
-      throw new Error('Restarting a closed DataContext is not possible!'); // See unsubscribe$
-    }
-
-    this.baselog.debug('Starting fresh dataContext ...');
-
-    this.started = false;
-
-    this._sort.replaceSorts(sorts || this.sort.sortsSnapshot);
-    this._filter.replaceFilters(filters || this.filter.filtersSnapshot);
-
-    this.started = true;
-
-    return this.reloadNow();
-  }
-
-  public reload(): void {
-    this._reloadQueue.next();
-  }
-
-  public findByIndex(key: any): T | undefined {
-    if (!this._indexFn) { throw new Error('findByIndex requires you to pass a index function!'); }
-    return this._primaryIndex.get(key);
-  }
-
-  /**
-   * Closes this DataContext and cleans up all used resources.
-   */
-  public close(): void {
-
-    this.started = false;
-    this.unsubscribe$.next();
-    this.unsubscribe$.complete();
-    this._closed.next(true);
-
-    this._data.complete();
-    this._total.complete();
-    this._status.complete();
-
-    this.clearAll();
-    this.baselog.debug('DataContext has been closed and resources cleaned up!');
-  }
-
-  public refresh(): void {
-    const current = this._data.getValue();
-    this._data.next(current);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Protected methods                                                       *
-   *                                                                         *
-   **************************************************************************/
-
-  protected reloadNow(): Observable<any> {
-    return this.reloadInternal(); // TODO This should actually return the real (http) request
-  }
-
-  /**
-   * Append the given rows to to existing ones.
-   */
-  protected appendData(additionalData: T[]): void {
-    // We had previous chunks so append to current data.
-    const newData = [...this.dataSnapshot];
-    newData.push(...additionalData);
-    this.indexAll(additionalData);
-    this.setData(newData, true);
-  }
-
-  /**
-   * 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 = false): void {
-
-    if (this._localApply) {
-      newData = this._localApply(newData);
-    }
-
-    if (this._localSort) {
-      newData = this._localSort(newData, this._sort.sortsSnapshot);
-    }
-
-    if (!alreadyIndexed) {
-      this.indexAll(newData);
-    }
-
-    const current = this.dataSnapshot;
-
-    if (!(current.length === 0 && newData.length === 0)) {
-      this.baselog.debug('Data has changed: ' + newData.length);
-      this._data.next(newData);
-    }
-  }
-
-  protected setTotal(total: number | undefined): void {
-    this._total.next(total);
-  }
-
-  /**
-   * Clears the current data-context cached data.
-   * State such as current sorting and filtersSnapshot are kept.
-   */
-  protected clearAll(silent = false): void {
-    this.clearIndex();
-
-    if (!silent) {
-      this.setTotal(0);
-      this.setData([]);
-    }
-
-    this.onIdle();
-  }
-
-  protected updateIndex(): void {
-    this.clearIndex();
-    this.indexAll(this.dataSnapshot);
-  }
-
-  /**
-   * Indexes the given item by key if there is an index function defined.
-   */
-  protected indexItem(item: T): void {
-    const key = this.getItemKey(item);
-    if (key) {
-      this._primaryIndex.set(key, item);
-    }
-  }
-
-  /**
-   * Indexes all the given items by key if there is an index function defined.
-   */
-  protected indexAll(items: T[]): void {
-    if (this._indexFn) {
-      items.forEach(item => this.indexItem(item));
-    }
-  }
-
-  protected getItemKey(item: T): any  {
-    if (this._indexFn) {
-      return this._indexFn(item);
-    }
-    return null;
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Event handler                                                           *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Occurs when the sort has changed.
-   */
-  protected onSortsChanged(sorts: Sort[]): void {
-    if (!this._localSort) {
-      this.reload();
-    } else {
-      this.setData(this.dataSnapshot, true);
-    }
-  }
-
-  /**
-   * Occurs when the filter has changed.
-   */
-  protected onFiltersChanged(filters: Filter[]): void {
-    this.reload();
-  }
-
-  protected onError(err: any): void {
-    this.onStatus(DataContextStatus.error(err));
-  }
-
-  protected onIdle(): void {
-    this.onStatus(DataContextStatus.idle());
-  }
-
-  protected onLoading(): void {
-    this.onStatus(DataContextStatus.loading());
-  }
-
-  protected onStatus(status: DataContextStatus): void {
-    this._status.next(status);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * 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(): void {
-    this._primaryIndex.clear();
-  }
-}