@sumaris-net/ngx-components 1.23.9 → 2.0.0-rc1

package/esm2020/src/app/shared/services/job.utils.mjs

@@ -0,0 +1,92 @@
+import { BehaviorSubject, defer } from 'rxjs';
+import { isNil, isNotNil, toNumber } from '../functions';
+// @dynamic
+export class JobUtils {
+    static defers(runnableList, opts) {
+        return runnableList.map(runnable => JobUtils.defer(runnable, opts));
+    }
+    static defer(runnable, opts) {
+        return defer(() => JobUtils.run(runnable, opts));
+    }
+    static run(runnable, opts) {
+        const progression = new BehaviorSubject(0);
+        runnable({ ...opts, progression })
+            .then(() => {
+            if (opts?.maxProgression)
+                progression.next(opts.maxProgression);
+            progression.complete();
+        })
+            .catch(err => progression.error(err));
+        return progression;
+    }
+    static async fetchAllPages(loadPageFn, opts) {
+        const maxProgression = toNumber(opts?.maxProgression, 100);
+        const progression = opts?.progression;
+        let total;
+        let pageCount;
+        let progressionStep;
+        let currentPageDataCount;
+        const fetchSize = toNumber(opts?.fetchSize, 1000);
+        if (fetchSize <= 0)
+            throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);
+        let offset = 0;
+        let data = [];
+        do {
+            if (opts && opts.logPrefix)
+                console.debug(`${opts.logPrefix} Fetching page #${offset / fetchSize}...`);
+            // Fetch a page
+            const res = await loadPageFn(offset, fetchSize);
+            // Concat to previous result
+            data = data.concat(res.data);
+            // Compute variables, for next loop
+            currentPageDataCount = res.data && res.data.length || 0;
+            offset += currentPageDataCount;
+            // Set total count (only once)
+            if (isNil(total) && isNotNil(res.total)) {
+                total = res.total;
+                // Compute the number of page
+                pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer
+                // Compute step, by dividing maxProgression by number of page
+                if (progression) {
+                    progressionStep = maxProgression / pageCount;
+                    // DEBUG
+                    if (opts && opts.logPrefix)
+                        console.debug(`${opts.logPrefix} {pageCount: ${pageCount}, progress: ${progression.value?.toFixed(2)}, pageProgressStep: ${progressionStep?.toFixed(1)}}`);
+                }
+            }
+            // Increment progression on each iteration (if possible)
+            if (isNotNil(progressionStep)) {
+                progression.next(progression.value + progressionStep);
+            }
+            if (opts?.onPageLoaded)
+                opts.onPageLoaded(res);
+        } while (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && (offset < total))));
+        // Complete progression to reach progressionStep value (because of round)
+        if (isNotNil(progressionStep)) {
+            // If total return by loadAll was bad !
+            if (isNotNil(total) && data.length < total) {
+                console.warn(`A function loadAll() returned a bad total (less than all page's data)! Expected ${total} but fetch ${data.length}`);
+                total = data.length;
+                pageCount = Math.round(data.length / fetchSize + 0.5);
+            }
+            // Compute final increment, using the real page count
+            progressionStep = Math.max(0, maxProgression - (progressionStep * pageCount));
+        }
+        // Or increment once (e.g. when total is not known, in received LoadResult)
+        else if (progression) {
+            progressionStep = maxProgression;
+        }
+        // DEBUG
+        if (opts && opts.logPrefix)
+            console.debug(`${opts.logPrefix} All pages fetched - {progress: ${progression.value?.toFixed(2)}, lastProgressStep: ${progressionStep?.toFixed(1)}`);
+        // Final increment
+        if (progression && progressionStep > 0) {
+            progression.next(progression.value + progressionStep);
+        }
+        return {
+            data,
+            total
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/job.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, defer, Observable } from 'rxjs';\nimport { isNil, isNotNil, toNumber } from '../functions';\nimport { LoadResult, LoadResultByPageFn } from './entity-service.class';\n\nexport type CallableWithProgressionFn<O extends CallableWithProgressionOptions> = (opts?: O) => Promise<any>;\nexport interface CallableWithProgressionOptions {\n  maxProgression?: number;\n  progression?: BehaviorSubject<number>;\n  [key: string]: any;\n}\n\n// @dynamic\nexport class JobUtils {\n\n  static defers<O extends CallableWithProgressionOptions>(runnableList: CallableWithProgressionFn<O>[], opts?: O): Observable<number>[] {\n    return runnableList.map(runnable => JobUtils.defer(runnable, opts));\n  }\n\n  static defer<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts?: O): Observable<number> {\n    return defer<Observable<number>>(() => JobUtils.run(runnable, opts));\n  }\n\n  static run<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts: O): Observable<number> {\n\n    const progression = new BehaviorSubject<number>(0);\n    runnable({...opts, progression})\n      .then(() => {\n        if (opts?.maxProgression) progression.next(opts.maxProgression);\n        progression.complete();\n      })\n      .catch(err => progression.error(err));\n    return progression;\n  }\n\n  static async fetchAllPages<T>(\n    loadPageFn: LoadResultByPageFn<T>,\n    opts?: {\n      progression?: BehaviorSubject<number>;\n      maxProgression?: number;\n      onPageLoaded?: (pageResult: LoadResult<T>) => any;\n      logPrefix?: string;\n      fetchSize?: number;\n    }): Promise<LoadResult<T>> {\n\n    const maxProgression = toNumber(opts?.maxProgression, 100);\n    const progression = opts?.progression;\n    let total; let pageCount; let progressionStep; let currentPageDataCount: number;\n    const fetchSize = toNumber(opts?.fetchSize, 1000);\n    if (fetchSize <= 0) throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);\n    let offset = 0;\n    let data: T[] = [];\n    do {\n\n      if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} Fetching page #${offset / fetchSize}...`);\n\n      // Fetch a page\n      const res = await loadPageFn(offset, fetchSize);\n\n      // Concat to previous result\n      data = data.concat(res.data);\n\n      // Compute variables, for next loop\n      currentPageDataCount = res.data && res.data.length || 0;\n      offset += currentPageDataCount;\n\n      // Set total count (only once)\n      if (isNil(total) && isNotNil(res.total)) {\n        total = res.total;\n        // Compute the number of page\n        pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer\n        // Compute step, by dividing maxProgression by number of page\n        if (progression) {\n          progressionStep = maxProgression / pageCount;\n          // DEBUG\n          if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} {pageCount: ${pageCount}, progress: ${progression.value?.toFixed(2)}, pageProgressStep: ${progressionStep?.toFixed(1)}}`);\n        }\n      }\n\n      // Increment progression on each iteration (if possible)\n      if (isNotNil(progressionStep)) {\n        progression.next(progression.value + progressionStep);\n      }\n\n      if (opts?.onPageLoaded) opts.onPageLoaded(res);\n\n    } while (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && (offset < total))));\n\n    // Complete progression to reach progressionStep value (because of round)\n    if (isNotNil(progressionStep)) {\n\n      // If total return by loadAll was bad !\n      if (isNotNil(total) && data.length < total) {\n        console.warn(`A function loadAll() returned a bad total (less than all page's data)! Expected ${total} but fetch ${data.length}`);\n        total = data.length;\n        pageCount = Math.round(data.length / fetchSize + 0.5);\n      }\n\n      // Compute final increment, using the real page count\n      progressionStep = Math.max(0, maxProgression - (progressionStep * pageCount));\n\n    }\n\n    // Or increment once (e.g. when total is not known, in received LoadResult)\n    else if (progression) {\n      progressionStep = maxProgression;\n    }\n\n    // DEBUG\n    if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} All pages fetched - {progress: ${progression.value?.toFixed(2)}, lastProgressStep: ${progressionStep?.toFixed(1)}`);\n\n    // Final increment\n    if (progression && progressionStep > 0) {\n      progression.next(progression.value + progressionStep);\n    }\n\n    return {\n      data,\n      total\n    };\n  }\n}\n"]}

package/esm2020/src/app/shared/services/memory-entity-service.class.mjs

@@ -0,0 +1,253 @@
+import { BehaviorSubject } from 'rxjs';
+import { filter, map, mergeMap, tap } from 'rxjs/operators';
+import { isEmptyArray, isNil, isNotEmptyArray, isNotNil } from '../functions';
+import { EntitiesService } from './entity-service.class';
+import { Directive } from '@angular/core';
+import { EntityUtils } from '../../core/services/model/entity.model';
+import { EntityFilter, EntityFilterUtils } from '../../core/services/model/filter.model';
+import { waitFor } from '../observables';
+import * as i0 from "@angular/core";
+// @dynamic
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class InMemoryEntitiesService extends EntitiesService {
+    constructor(dataType, filterType, options) {
+        super();
+        this.dataType = dataType;
+        this.filterType = filterType;
+        this.debug = false;
+        this.dirty = false;
+        this._saving = false;
+        this.dataSubject = new BehaviorSubject(null);
+        options = {
+            onSort: this.sort,
+            ...options
+        };
+        this._sortFn = options.onSort;
+        this._onLoad = options.onLoad;
+        this._onSaveFn = options.onSave;
+        this._equalsFn = options.equals;
+        this._filterFnFactory = options.filterFnFactory || ((f) => {
+            const filter = this.asFilter(f);
+            if (filter instanceof EntityFilter) {
+                return filter.asFilterFn();
+            }
+            return undefined;
+        });
+        this._sortByReplacement = {
+            // Detect rankOrder on the entity class
+            id: (Object.getOwnPropertyNames(new dataType()).findIndex(key => key === 'rankOrder') !== -1) ? 'rankOrder' : undefined,
+            ...options.sortByReplacement
+        };
+    }
+    set value(data) {
+        this.setValue(data);
+    }
+    get value() {
+        return this.dataSubject.getValue();
+    }
+    ngOnDestroy() {
+        if (this.debug)
+            console.debug('[memory-data-service] Destroying...');
+        this.dataSubject.complete();
+        this.dataSubject.unsubscribe();
+    }
+    setValue(data) {
+        if (this.dataSubject.value !== data) {
+            this._hiddenData = [];
+            this.dataSubject.next(data);
+        }
+        this.dirty = false;
+    }
+    async loadAll(offset, size, sortBy, sortDirection, filter, opts) {
+        offset = offset >= 0 ? offset : 0;
+        size = size >= 0 ? size : -1;
+        const originalData = this.dataSubject.value;
+        if (isNil(originalData)) {
+            console.warn('[memory-data-service] Cannot load all: no value set. Will return empty result');
+        }
+        // Wait end of saving
+        if (this._saving)
+            await waitFor(() => !this._saving);
+        const excludedDataByFilter = [];
+        let excludedDataByPagination;
+        try {
+            if (isEmptyArray(originalData)) {
+                return { data: [], total: 0 };
+            }
+            // Apply sort
+            let data = this._sortFn(originalData, sortBy, sortDirection);
+            if (this._onLoad) {
+                data = await this._onLoad(data);
+            }
+            // Apply filter (will update hiddenData)
+            data = this.filter(data, filter, excludedDataByFilter);
+            // Compute the total length
+            const total = data.length;
+            // If page size=0 (e.g. only need total)
+            if (size === 0) {
+                excludedDataByPagination = data;
+                return { data: [], total };
+            }
+            // Slice in a page (using offset and size)
+            if (offset > 0) {
+                // Offset after the end: no result
+                if (offset >= data.length) {
+                    excludedDataByPagination = data;
+                    data = [];
+                }
+                else {
+                    excludedDataByPagination = (size > 0 && ((offset + size) < data.length))
+                        // Slice using limit to size
+                        ? data.slice(0, offset - 1).concat(data.slice(offset + size))
+                        // Slice without limit
+                        : data.slice(0, offset - 1);
+                    data = (size > 0 && ((offset + size) < data.length))
+                        // Slice using limit to size
+                        ? data.slice(offset, offset + size)
+                        // Slice without limit
+                        : data.slice(offset);
+                }
+            }
+            // Apply a limit
+            else if (size > 0) {
+                excludedDataByPagination = data.slice(size);
+                data = data.slice(0, size);
+            }
+            // No limit:
+            else if (size === -1) {
+                // Keep all data
+            }
+            // /!\ If already observed, then always create a copy of the original array
+            // Because datasource will only update if the array changed
+            if (data === originalData) {
+                data = data.slice();
+            }
+            const res = { data, total };
+            const nextOffset = (offset || 0) + size;
+            if (nextOffset < total) {
+                res.fetchMore = () => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, opts)
+                    .then(res => {
+                    // Update hidden data (remove new fetched item)
+                    if (res.data?.length) {
+                        this._hiddenData = this._hiddenData.filter(item => !res.data.includes(item));
+                    }
+                    return res;
+                });
+            }
+            return res;
+        }
+        finally {
+            // Remember hidden data
+            if (offset === 0) {
+                this._hiddenData = !excludedDataByPagination ? excludedDataByFilter : excludedDataByFilter.concat(...excludedDataByPagination);
+            }
+        }
+    }
+    watchAll(offset, size, sortBy, sortDirection, filterData, options) {
+        offset = offset >= 0 ? offset : 0;
+        size = size >= 0 ? size : -1;
+        return this.dataSubject
+            .pipe(
+        // Warn if waiting value to be set
+        tap((data) => !data && console.warn('[memory-data-service] Waiting value to be set...')), filter(isNotNil), mergeMap(_ => this.loadAll(offset, size, sortBy, sortDirection, filterData, options)));
+    }
+    async saveAll(data, options) {
+        if (!this.dataSubject.value)
+            throw new Error('[memory-service] Could not save, because value not set');
+        this.markAsSaving();
+        try {
+            // Restore hidden data
+            if (isNotEmptyArray(this._hiddenData))
+                data = data.concat(...this._hiddenData);
+            if (this._onSaveFn) {
+                const res = this._onSaveFn(data);
+                data = ((res instanceof Promise)) ? await res : res;
+            }
+            this.dataSubject.next(data);
+            this.dirty = true;
+            return data;
+        }
+        finally {
+            this.markAsSaved();
+        }
+    }
+    async deleteAll(dataToRemove, options) {
+        let data = this.dataSubject.value;
+        if (!data)
+            throw new Error('[memory-service] Could not delete, because value not set');
+        // Remove deleted item, from data
+        const updatedData = data.filter(entity => {
+            const removed = dataToRemove.findIndex(entityToRemove => this.equals(entityToRemove, entity)) !== -1;
+            return !removed;
+        });
+        const deleteCount = data.length - updatedData.length;
+        if (deleteCount > 0) {
+            data = updatedData;
+            this.dirty = true;
+            this.dataSubject.next(data);
+        }
+    }
+    sort(data, sortBy, sortDirection) {
+        // Replace sortBy, using the replacement map
+        sortBy = sortBy && this._sortByReplacement[sortBy] || sortBy || 'id';
+        // Execute the sort
+        return EntityUtils.sort(data, sortBy, sortDirection);
+    }
+    asFilter(source) {
+        return EntityFilterUtils.fromObject(source, this.filterType);
+    }
+    addSortByReplacement(source, target) {
+        this._sortByReplacement[source] = target;
+    }
+    equals(d1, d2) {
+        if (this._equalsFn)
+            return this._equalsFn(d1, d2);
+        return d1 && d1.equals ? d1.equals(d2) : EntityUtils.equals(d1, d2, 'id');
+    }
+    /**
+     * Count data stored by the service (without hidden data).
+     * @param opts
+     */
+    get count() {
+        return (this.dataSubject.value?.length || 0);
+    }
+    get hiddenCount() {
+        return this._hiddenData?.length || 0;
+    }
+    /* -- protected methods -- */
+    filter(data, _filter, hiddenData) {
+        // if filter is DataFilter instance, use its test function
+        const filterFn = this._filterFnFactory && this._filterFnFactory(_filter);
+        if (filterFn) {
+            const filteredData = [];
+            data.forEach(value => {
+                if (filterFn(value))
+                    filteredData.push(value);
+                else
+                    hiddenData.push(value);
+            });
+            return filteredData;
+        }
+        // default, no filter
+        return data;
+    }
+    connect() {
+        return this.dataSubject.pipe(map((data) => {
+            data = data || [];
+            const total = data.length;
+            return { data, total };
+        }));
+    }
+    markAsSaving() {
+        this._saving = true;
+    }
+    markAsSaved() {
+        this._saving = false;
+    }
+}
+InMemoryEntitiesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: InMemoryEntitiesService, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+InMemoryEntitiesService.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.1", type: InMemoryEntitiesService, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: InMemoryEntitiesService, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: undefined }, { type: undefined }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memory-entity-service.class.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/memory-entity-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {BehaviorSubject, Observable} from 'rxjs';\nimport {filter, map, mergeMap, tap} from 'rxjs/operators';\nimport {isEmptyArray, isNil, isNotEmptyArray, isNotNil} from '../functions';\nimport {EntitiesService, EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, FilterFn, FilterFnFactory, IEntitiesService, LoadResult} from './entity-service.class';\nimport {SortDirection} from '@angular/material/sort';\nimport {Directive, OnDestroy} from '@angular/core';\nimport {EntityUtils, IEntity} from '../../core/services/model/entity.model';\nimport {EntityFilter, EntityFilterUtils} from '../../core/services/model/filter.model';\nimport {waitFor} from '../observables';\n\nexport interface InMemoryEntitiesServiceOptions<T, F> {\n  onSort?: (data: T[], sortBy?: string, sortDirection?: SortDirection) => T[];\n  onLoad?: (data: T[]) => T[] | Promise<T[]>;\n  onSave?: (data: T[]) => T[] | Promise<T[]>;\n  equals?: (d1: T, d2: T) => boolean;\n\n  filterFnFactory?: FilterFnFactory<T, F>;\n  filterFn?: FilterFn<T>;\n\n  sortByReplacement?: { [key: string]: string };\n}\n\n// @dynamic\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class InMemoryEntitiesService<\n  T extends IEntity<T, ID>,\n  F = any,\n  ID = number,\n  O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions>\n  extends EntitiesService<T, F, ID>\n  implements IEntitiesService<T, F, O>, OnDestroy {\n\n  debug = false;\n  dirty = false;\n\n  private _hiddenData: T[];\n  private _saving = false;\n\n  private readonly dataSubject = new BehaviorSubject<T[]>(null);\n  private readonly _sortFn: (data: T[], sortBy?: string, sortDirection?: SortDirection) => T[];\n  private readonly _onLoad: (data: T[]) => T[] | Promise<T[]>;\n  private readonly _onSaveFn: (data: T[]) => T[] | Promise<T[]>;\n  private readonly _equalsFn: (d1: T, d2: T) => boolean;\n  private readonly _filterFnFactory: FilterFnFactory<T, F>;\n  private readonly _sortByReplacement: { [key: string]: string };\n\n\n  set value(data: T[]) {\n    this.setValue(data);\n  }\n\n  get value(): T[] {\n    return this.dataSubject.getValue();\n  }\n\n  constructor(\n    protected dataType: new() => T,\n    protected filterType: new() => F,\n    options?: InMemoryEntitiesServiceOptions<T, F>\n  ) {\n    super();\n    options = {\n      onSort: this.sort,\n      ...options\n    };\n\n    this._sortFn = options.onSort;\n    this._onLoad = options.onLoad;\n    this._onSaveFn = options.onSave;\n    this._equalsFn = options.equals;\n    this._filterFnFactory = options.filterFnFactory || ((f) => {\n      const filter = this.asFilter(f) as F;\n      if (filter instanceof EntityFilter) {\n        return filter.asFilterFn();\n      }\n      return undefined;\n    });\n\n    this._sortByReplacement = {\n      // Detect rankOrder on the entity class\n      id: (Object.getOwnPropertyNames(new dataType()).findIndex(key => key === 'rankOrder') !== -1) ? 'rankOrder' : undefined,\n      ...options.sortByReplacement\n    };\n  }\n\n  ngOnDestroy() {\n    if (this.debug) console.debug('[memory-data-service] Destroying...');\n    this.dataSubject.complete();\n    this.dataSubject.unsubscribe();\n  }\n\n  setValue(data: T[]) {\n    if (this.dataSubject.value !== data) {\n      this._hiddenData = [];\n      this.dataSubject.next(data);\n    }\n    this.dirty = false;\n  }\n\n  async loadAll(\n    offset: number,\n    size: number,\n    sortBy?: string,\n    sortDirection?: SortDirection,\n    filter?: F,\n    opts?: EntitiesServiceLoadOptions\n  ): Promise<LoadResult<T>> {\n\n    offset = offset >= 0 ? offset : 0;\n    size = size >= 0 ? size : -1;\n\n    const originalData = this.dataSubject.value;\n    if (isNil(originalData)) {\n      console.warn('[memory-data-service] Cannot load all: no value set. Will return empty result');\n    }\n\n    // Wait end of saving\n    if (this._saving) await waitFor(() => !this._saving);\n\n    const excludedDataByFilter: T[] = [];\n    let excludedDataByPagination: T[];\n\n    try {\n      if (isEmptyArray(originalData)) {\n        return {data: [], total: 0};\n      }\n\n      // Apply sort\n      let data = this._sortFn(originalData, sortBy, sortDirection) ;\n\n      if (this._onLoad) {\n        data = await this._onLoad(data);\n      }\n\n      // Apply filter (will update hiddenData)\n      data = this.filter(data, filter, excludedDataByFilter);\n\n      // Compute the total length\n      const total = data.length;\n\n      // If page size=0 (e.g. only need total)\n      if (size === 0) {\n        excludedDataByPagination = data;\n        return {data: [], total};\n      }\n\n      // Slice in a page (using offset and size)\n      if (offset > 0) {\n\n        // Offset after the end: no result\n        if (offset >= data.length) {\n          excludedDataByPagination = data;\n          data = [];\n        }\n        else {\n          excludedDataByPagination = (size > 0 && ((offset + size) < data.length))\n            // Slice using limit to size\n            ? data.slice(0, offset -1).concat(data.slice(offset + size))\n            // Slice without limit\n            : data.slice(0, offset-1);\n\n          data = (size > 0 && ((offset + size) < data.length))\n            // Slice using limit to size\n            ? data.slice(offset, offset + size)\n            // Slice without limit\n            : data.slice(offset);\n        }\n      }\n\n      // Apply a limit\n      else if (size > 0){\n        excludedDataByPagination = data.slice(size);\n        data = data.slice(0, size);\n      }\n\n      // No limit:\n      else if (size === -1){\n        // Keep all data\n      }\n\n      // /!\\ If already observed, then always create a copy of the original array\n      // Because datasource will only update if the array changed\n      if (data === originalData) {\n        data = data.slice();\n      }\n\n      const res: LoadResult<T> = {data, total};\n\n      const nextOffset = (offset || 0) + size;\n      if (nextOffset < total) {\n        res.fetchMore = () => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, opts)\n          .then(res => {\n            // Update hidden data (remove new fetched item)\n            if (res.data?.length) {\n              this._hiddenData = this._hiddenData.filter(item => !res.data.includes(item))\n            }\n            return res;\n          });\n      }\n\n      return res;\n    }\n    finally {\n      // Remember hidden data\n      if (offset === 0) {\n        this._hiddenData = !excludedDataByPagination ? excludedDataByFilter : excludedDataByFilter.concat(...excludedDataByPagination);\n      }\n    }\n  }\n\n  watchAll(\n    offset: number,\n    size: number,\n    sortBy?: string,\n    sortDirection?: SortDirection,\n    filterData?: F,\n    options?: any\n  ): Observable<LoadResult<T>> {\n\n    offset = offset >= 0 ? offset : 0;\n    size = size >= 0 ? size : -1;\n\n    return this.dataSubject\n      .pipe(\n        // Warn if waiting value to be set\n        tap((data) => !data && console.warn('[memory-data-service] Waiting value to be set...')),\n        filter(isNotNil),\n        mergeMap(_ => this.loadAll(offset, size, sortBy, sortDirection, filterData, options))\n      );\n  }\n\n  async saveAll(data: T[], options?: any): Promise<T[]> {\n    if (!this.dataSubject.value) throw new Error('[memory-service] Could not save, because value not set');\n\n    this.markAsSaving();\n\n    try {\n\n      // Restore hidden data\n      if (isNotEmptyArray(this._hiddenData))\n        data = data.concat(...this._hiddenData);\n\n      if (this._onSaveFn) {\n        const res = this._onSaveFn(data);\n        data = ((res instanceof Promise)) ? await res : res;\n      }\n\n      this.dataSubject.next(data);\n      this.dirty = true;\n      return data;\n    }\n    finally {\n      this.markAsSaved();\n    }\n  }\n\n  async deleteAll(dataToRemove: T[], options?: any): Promise<any> {\n    let data = this.dataSubject.value;\n    if (!data) throw new Error('[memory-service] Could not delete, because value not set');\n\n    // Remove deleted item, from data\n    const updatedData = data.filter(entity => {\n      const removed = dataToRemove.findIndex(entityToRemove => this.equals(entityToRemove, entity)) !== -1;\n      return !removed;\n    });\n    const deleteCount = data.length - updatedData.length;\n    if (deleteCount > 0) {\n      data = updatedData;\n      this.dirty = true;\n      this.dataSubject.next(data);\n    }\n  }\n\n  sort(data: T[], sortBy?: string, sortDirection?: SortDirection): T[] {\n    // Replace sortBy, using the replacement map\n    sortBy = sortBy && this._sortByReplacement[sortBy] || sortBy || 'id';\n\n    // Execute the sort\n    return EntityUtils.sort(data, sortBy, sortDirection);\n  }\n\n  asFilter(source: Partial<F>): F {\n    return EntityFilterUtils.fromObject(source, this.filterType);\n  }\n\n  addSortByReplacement(source: string, target: string) {\n    this._sortByReplacement[source] = target;\n  }\n\n  equals(d1: T, d2: T): boolean {\n    if (this._equalsFn) return this._equalsFn(d1, d2);\n    return d1 && d1.equals ? d1.equals(d2) : EntityUtils.equals(d1, d2, 'id');\n  }\n\n  /**\n   * Count data stored by the service (without hidden data).\n   * @param opts\n   */\n  get count(): number {\n    return (this.dataSubject.value?.length || 0);\n  }\n\n  get hiddenCount(): number {\n    return this._hiddenData?.length || 0;\n  }\n\n  /* -- protected methods -- */\n\n  protected filter(data: T[], _filter: F, hiddenData: T[]): T[] {\n\n    // if filter is DataFilter instance, use its test function\n    const filterFn = this._filterFnFactory && this._filterFnFactory(_filter);\n    if (filterFn) {\n      const filteredData = [];\n\n      data.forEach(value => {\n        if (filterFn(value))\n          filteredData.push(value);\n        else\n          hiddenData.push(value);\n      });\n\n      return filteredData;\n    }\n\n    // default, no filter\n    return data;\n  }\n\n  protected connect(): Observable<LoadResult<T>> {\n    return this.dataSubject.pipe(\n      map((data) => {\n        data = data || [];\n        const total = data.length;\n        return {data, total};\n      })\n    );\n  }\n\n  protected markAsSaving() {\n    this._saving = true;\n  }\n\n  protected markAsSaved() {\n    this._saving = false;\n  }\n}\n"]}

package/esm2020/src/app/shared/services/progress-bar.service.mjs

@@ -0,0 +1,32 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProgressBarService {
+    constructor() {
+        this._requestsRunning = 0;
+        this.onProgressChanged = new EventEmitter();
+    }
+    list() {
+        return this._requestsRunning;
+    }
+    increase() {
+        this._requestsRunning++;
+        if (this._requestsRunning === 1) {
+            this.onProgressChanged.emit('query');
+        }
+    }
+    decrease() {
+        if (this._requestsRunning > 0) {
+            this._requestsRunning--;
+        }
+        if (this._requestsRunning === 0) {
+            this.onProgressChanged.emit(null);
+        }
+    }
+}
+ProgressBarService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ProgressBarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ProgressBarService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ProgressBarService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: ProgressBarService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/services/startable-service.class.mjs

@@ -0,0 +1,94 @@
+import { __decorate, __param } from "tslib";
+import { Optional } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { waitFor } from '../observables';
+let StartableService = class StartableService {
+    constructor(prerequisiteService) {
+        this.onStart = new Subject();
+        this._debug = false;
+        this._startByReadyFunction = true; // should start when calling ready() ?
+        this._data = null;
+        this._started = false;
+        this._startPromise = null;
+        this._startPrerequisite = null;
+        this._subscription = null;
+        this._startPrerequisite = prerequisiteService
+            ? () => prerequisiteService.ready()
+            : () => Promise.resolve();
+    }
+    start() {
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._started)
+            return Promise.resolve(this._data);
+        this._startPromise = this._startPrerequisite()
+            .then(() => this.ngOnStart())
+            .then(data => {
+            this._data = data;
+            this._started = true;
+            this._startPromise = undefined;
+            this.onStart.next(this._data);
+            return this._data;
+        })
+            .catch(err => {
+            console.error('Failed to start a service: ' + (err && err.message || err), err);
+            this._started = false;
+            this._startPromise = null;
+            return null;
+        });
+        return this._startPromise;
+    }
+    async stop() {
+        try {
+            if (this._subscription) {
+                this._subscription.unsubscribe();
+                this._subscription = null;
+            }
+            await this.ngOnStop();
+            this._started = false;
+            this._startPromise = undefined;
+        }
+        catch (err) {
+            console.error('Failed to stop a service: ' + (err && err.message || err), err);
+        }
+    }
+    async restart() {
+        if (this._startPromise)
+            await this._startPromise; // Wait end of previous loading
+        if (this._started)
+            await this.stop(); // Then stop if started
+        return this.start(); // Then start again
+    }
+    get started() {
+        return this._started;
+    }
+    get starting() {
+        return !!this._startPromise;
+    }
+    ready() {
+        if (this._started)
+            return Promise.resolve(this._data);
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._startByReadyFunction)
+            return this.start();
+        return waitFor(() => this._started)
+            .then(() => this._data);
+    }
+    registerSubscription(sub) {
+        this._subscription = this._subscription || new Subscription();
+        this._subscription.add(sub);
+        return sub;
+    }
+    unregisterSubscription(sub) {
+        this._subscription.remove(sub);
+    }
+    async ngOnStop() {
+        // Can be override by subclasses
+    }
+};
+StartableService = __decorate([
+    __param(0, Optional())
+], StartableService);
+export { StartableService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"startable-service.class.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/startable-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {Optional} from '@angular/core';\nimport {Subject, Subscription} from 'rxjs';\nimport {waitFor} from '../observables';\n\nexport interface IStartableService<T = any> {\n  started: boolean;\n  start(): Promise<T>;\n  stop(): Promise<void>;\n  ready(): Promise<T>;\n}\n\nexport abstract class StartableService<T = any> implements IStartableService<T> {\n\n  onStart = new Subject<T>();\n\n  protected _debug = false;\n  protected _startByReadyFunction = true; // should start when calling ready() ?\n  protected _data: T = null;\n\n  private _started = false;\n  private _startPromise: Promise<T> = null;\n  private _startPrerequisite: () => Promise<any> = null;\n  private _subscription: Subscription = null;\n\n  protected constructor(\n    @Optional() prerequisiteService: { ready: () => Promise<any> }\n  ) {\n    this._startPrerequisite = prerequisiteService\n      ? () => prerequisiteService.ready()\n      : () => Promise.resolve();\n  }\n\n  start(): Promise<T> {\n    if (this._startPromise) return this._startPromise;\n    if (this._started) return Promise.resolve(this._data);\n\n    this._startPromise = this._startPrerequisite()\n      .then(() => this.ngOnStart())\n      .then(data => {\n        this._data = data;\n\n        this._started = true;\n        this._startPromise = undefined;\n\n        this.onStart.next(this._data);\n\n        return this._data;\n      })\n      .catch(err => {\n        console.error('Failed to start a service: ' + (err && err.message || err), err);\n        this._started = false;\n        this._startPromise = null;\n        return null;\n      });\n    return this._startPromise;\n  }\n\n\n  async stop() {\n    try {\n      if (this._subscription) {\n        this._subscription.unsubscribe();\n        this._subscription = null;\n      }\n      await this.ngOnStop();\n      this._started = false;\n      this._startPromise = undefined;\n    }\n    catch (err) {\n      console.error('Failed to stop a service: ' + (err && err.message || err), err);\n    }\n  }\n\n  async restart(): Promise<T> {\n    if (this._startPromise) await this._startPromise; // Wait end of previous loading\n    if (this._started) await this.stop(); // Then stop if started\n    return this.start(); // Then start again\n  }\n\n  get started(): boolean {\n    return this._started;\n  }\n\n  get starting(): boolean {\n    return !!this._startPromise;\n  }\n\n  ready(): Promise<T> {\n    if (this._started) return Promise.resolve(this._data);\n    if (this._startPromise) return this._startPromise;\n    if (this._startByReadyFunction) return this.start();\n    return waitFor(() => this._started)\n      .then(() => this._data);\n  }\n\n  protected registerSubscription(sub: Subscription): Subscription {\n    this._subscription = this._subscription || new Subscription();\n    this._subscription.add(sub);\n    return sub;\n  }\n\n  protected unregisterSubscription(sub: Subscription): void {\n    this._subscription.remove(sub);\n  }\n\n  protected async ngOnStop(): Promise<void> {\n    // Can be override by subclasses\n  }\n\n  protected abstract ngOnStart(): Promise<T>;\n}\n"]}