@sumaris-net/ngx-components 1.2.7 → 1.2.14

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

@@ -0,0 +1,119 @@
+import { __decorate, __param } from "tslib";
+import { Optional } from '@angular/core';
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+/**
+ * Same as StartableService, bu with a dataSubject instead of a simple 'data' property
+ */
+let StartableObservableService = class StartableObservableService {
+    constructor(prerequisiteService) {
+        this.dataSubject = new BehaviorSubject(null);
+        this.startSubject = new Subject();
+        this.stopSubject = new Subject();
+        this._debug = false;
+        this._startByReadyFunction = true; // should start when calling ready() ?
+        this._started = false;
+        this._startPromise = null;
+        this._startPrerequisite = null;
+        this._subscription = null;
+        this._startPrerequisite = prerequisiteService
+            ? () => prerequisiteService.ready()
+            : () => Promise.resolve();
+    }
+    start(opts) {
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._started)
+            return Promise.resolve(this.dataSubject.value);
+        this._startPromise = this._startPrerequisite()
+            .then(() => this.ngOnStart(opts))
+            .then(data => {
+            this._started = true;
+            this._startPromise = undefined;
+            // Should be done AFTER 'this._started = true', because of the 'filter' operator, inside ready() function
+            this.dataSubject.next(data);
+            this.startSubject.next(data);
+            return data;
+        })
+            .catch(err => {
+            if (!this.stopped) {
+                console.error('Failed to start a service: ' + (err && err.message || err), err);
+                this._started = false;
+                this._startPromise = null;
+            }
+            return null;
+        });
+        return this._startPromise;
+    }
+    ready() {
+        if (this._started)
+            return Promise.resolve(this.dataSubject.value);
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._startByReadyFunction)
+            return this.start();
+        return this.dataSubject
+            .pipe(takeUntil(this.stopSubject), 
+        // Wait start() to be called, to exclude the initial 'null' value
+        filter(_ => this._started))
+            .toPromise();
+    }
+    async stop() {
+        try {
+            this.unsubscribe();
+            await this.ngOnStop();
+        }
+        catch (err) {
+            console.error('Failed to stop a service: ' + (err && err.message || err), err);
+        }
+        finally {
+            this._started = false;
+            this._startPromise = undefined;
+            this.stopSubject.next(); // Stop all running observables
+            this.dataSubject.next(null); // Reset data
+        }
+    }
+    async restart(opts) {
+        if (this._startPromise)
+            await this._startPromise; // Wait end of previous loading
+        if (this._started)
+            await this.stop(); // Then stop if started
+        return this.start(opts); // Then start again
+    }
+    get started() {
+        return this._started;
+    }
+    get starting() {
+        return !!this._startPromise;
+    }
+    get stopped() {
+        return !this._started && !this._startPromise;
+    }
+    get data() {
+        return this.dataSubject.value;
+    }
+    set data(value) {
+        if (this.dataSubject.value !== value) {
+            this.dataSubject.next(value);
+        }
+    }
+    registerSubscription(sub) {
+        this._subscription = this._subscription || new Subscription();
+        this._subscription.add(sub);
+    }
+    unregisterSubscription(sub) {
+        this._subscription?.remove(sub);
+    }
+    unsubscribe() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+    }
+    ngOnStop() {
+        // Can be overwritten by subclasses
+    }
+};
+StartableObservableService = __decorate([
+    __param(0, Optional())
+], StartableObservableService);
+export { StartableObservableService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"startable-observable-service.class.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/startable-observable-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {Optional} from '@angular/core';\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\nimport {filter, takeUntil} from 'rxjs/operators';\nimport {IStartableService} from './startable-service.class';\n\n/**\n * Same as StartableService, bu with a dataSubject instead of a simple 'data' property\n */\nexport abstract class StartableObservableService<T = any, O = any> implements IStartableService<T> {\n\n  readonly dataSubject = new BehaviorSubject<T>(null);\n  readonly startSubject = new Subject<T>();\n  readonly stopSubject = new Subject<void>();\n\n  protected _debug = false;\n  protected _startByReadyFunction = true; // should start when calling ready() ?\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(opts?: O): Promise<T> {\n    if (this._startPromise) return this._startPromise;\n    if (this._started) return Promise.resolve(this.dataSubject.value);\n\n    this._startPromise = this._startPrerequisite()\n      .then(() => this.ngOnStart(opts))\n      .then(data => {\n\n        this._started = true;\n        this._startPromise = undefined;\n\n        // Should be done AFTER 'this._started = true', because of the 'filter' operator, inside ready() function\n        this.dataSubject.next(data);\n        this.startSubject.next(data);\n\n        return data;\n      })\n      .catch(err => {\n        if (!this.stopped) {\n          console.error('Failed to start a service: ' + (err && err.message || err), err);\n          this._started = false;\n          this._startPromise = null;\n        }\n        return null;\n      });\n    return this._startPromise;\n  }\n\n  ready(): Promise<T> {\n    if (this._started) return Promise.resolve(this.dataSubject.value);\n    if (this._startPromise) return this._startPromise;\n    if (this._startByReadyFunction) return this.start();\n\n    return this.dataSubject\n      .pipe(\n        takeUntil(this.stopSubject),\n        // Wait start() to be called, to exclude the initial 'null' value\n        filter(_ => this._started)\n      )\n      .toPromise();\n  }\n\n  async stop() {\n\n    try {\n      this.unsubscribe();\n      await this.ngOnStop();\n    }\n    catch (err) {\n      console.error('Failed to stop a service: ' + (err && err.message || err), err);\n    }\n    finally {\n      this._started = false;\n      this._startPromise = undefined;\n      this.stopSubject.next(); // Stop all running observables\n      this.dataSubject.next(null); // Reset data\n    }\n  }\n\n  async restart(opts?: O): 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(opts); // 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  get stopped(): boolean {\n    return !this._started && !this._startPromise;\n  }\n\n  protected get data(): T {\n    return this.dataSubject.value;\n  }\n\n  protected set data(value: T) {\n    if (this.dataSubject.value !== value) {\n      this.dataSubject.next(value);\n    }\n  }\n\n  protected registerSubscription(sub: Subscription) {\n    this._subscription = this._subscription || new Subscription();\n    this._subscription.add(sub);\n  }\n\n  protected unregisterSubscription(sub: Subscription): void {\n    this._subscription?.remove(sub);\n  }\n\n  protected unsubscribe() {\n    this._subscription?.unsubscribe();\n    this._subscription = null;\n  }\n\n  protected ngOnStop(): Promise<void> | void {\n    // Can be overwritten by subclasses\n  }\n\n  protected abstract ngOnStart(opts?: O): Promise<T>;\n}\n"]}

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

@@ -0,0 +1,105 @@
+import { __decorate, __param } from "tslib";
+import { Optional } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+let StartableService = class StartableService {
+    constructor(prerequisiteService) {
+        this.startSubject = new Subject();
+        this.stopSubject = 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(opts) {
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._started)
+            return Promise.resolve(this._data);
+        this._startPromise = this._startPrerequisite()
+            .then(() => this.ngOnStart(opts))
+            .then(data => {
+            this._data = data;
+            this._started = true;
+            this._startPromise = undefined;
+            this.startSubject.next(data);
+            return data;
+        })
+            .catch(err => {
+            if (!this.stopped) {
+                console.error('Failed to start a service: ' + (err && err.message || err), err);
+                this._startPromise = null;
+                this._started = false;
+            }
+            return null;
+        });
+        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 this.startSubject
+            .pipe(takeUntil(this.stopSubject))
+            .toPromise();
+    }
+    async stop() {
+        try {
+            this.unsubscribe();
+            await this.ngOnStop();
+        }
+        catch (err) {
+            console.error('Failed to stop a service: ' + (err && err.message || err), err);
+        }
+        finally {
+            this._data = null;
+            this._started = false;
+            this._startPromise = undefined;
+            this.stopSubject.next();
+        }
+    }
+    async restart(opts) {
+        if (this._startPromise)
+            await this._startPromise; // Wait end of previous loading
+        if (this._started)
+            await this.stop(); // Then stop if started
+        return this.start(opts); // Then start again
+    }
+    get started() {
+        return this._started;
+    }
+    get starting() {
+        return !!this._startPromise;
+    }
+    get stopped() {
+        return !this._started && !this._startPromise;
+    }
+    registerSubscription(sub) {
+        this._subscription = this._subscription || new Subscription();
+        this._subscription.add(sub);
+    }
+    unregisterSubscription(sub) {
+        this._subscription?.remove(sub);
+    }
+    unsubscribe() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+    }
+    ngOnStop() {
+        // Can be overwritten 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 {takeUntil} from 'rxjs/operators';\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, O = any> implements IStartableService<T> {\n\n  readonly startSubject = new Subject<T>();\n  readonly stopSubject = new Subject<void>();\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(opts?: O): 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(opts))\n      .then(data => {\n        this._data = data;\n\n        this._started = true;\n        this._startPromise = undefined;\n\n        this.startSubject.next(data);\n\n        return data;\n      })\n      .catch(err => {\n        if (!this.stopped) {\n          console.error('Failed to start a service: ' + (err && err.message || err), err);\n          this._startPromise = null;\n          this._started = false;\n        }\n        return null;\n      });\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\n    return this.startSubject\n      .pipe(takeUntil(this.stopSubject))\n      .toPromise();\n  }\n\n  async stop() {\n    try {\n      this.unsubscribe();\n      await this.ngOnStop();\n    }\n    catch (err) {\n      console.error('Failed to stop a service: ' + (err && err.message || err), err);\n    }\n    finally {\n      this._data = null;\n      this._started = false;\n      this._startPromise = undefined;\n      this.stopSubject.next();\n    }\n  }\n\n  async restart(opts?: O): 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(opts); // 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  get stopped(): boolean {\n    return !this._started && !this._startPromise;\n  }\n\n  protected registerSubscription(sub: Subscription) {\n    this._subscription = this._subscription || new Subscription();\n    this._subscription.add(sub);\n  }\n\n  protected unregisterSubscription(sub: Subscription): void {\n    this._subscription?.remove(sub);\n  }\n\n  protected unsubscribe() {\n    this._subscription?.unsubscribe();\n    this._subscription = null;\n  }\n\n  protected ngOnStop(): Promise<void> | void {\n    // Can be overwritten by subclasses\n  }\n\n  protected abstract ngOnStart(opts?: O): Promise<T>;\n}\n"]}

package/esm2020/src/app/shared/services/storage/storage.service.mjs

@@ -0,0 +1,132 @@
+import { Inject, Injectable } from '@angular/core';
+import { StorageDrivers } from './storage.utils';
+import { StartableService } from '../startable-service.class';
+import { environment } from '../../../../environments/environment';
+import { ENVIRONMENT } from '../../../../environments/environment.class';
+import * as cordovaSQLiteDriver from 'localforage-cordovasqlitedriver';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@ionic/storage-angular";
+import * as i3 from "../../../../environments/environment.class";
+export class StorageService extends StartableService {
+    constructor(platform, storage, environment) {
+        super(platform);
+        this.platform = platform;
+        this.storage = storage;
+        this.environment = environment;
+        this._debug = !environment.production;
+        this.start();
+    }
+    get driver() {
+        return this._data?.driver;
+    }
+    async ngOnStart() {
+        try {
+            console.debug(`[storage-service] Starting... {driverOrder: ${environment.storage?.driverOrder}}`);
+            // Define Cordova SQLLite driver
+            await this.storage.defineDriver(cordovaSQLiteDriver);
+            // Create the storage instance
+            const storage = await this.storage.create();
+            // Migrate from old storage
+            await this.migrate(storage);
+            console.info(`[storage-service] Started using driver: ${storage?.driver}`);
+            return storage;
+        }
+        catch (err) {
+            console.error('[storage-service] Cannot create storage: ' + (err?.message || err), err);
+        }
+    }
+    async migrate(storage) {
+        const canMigrate = storage?.driver === StorageDrivers.SQLLite;
+        if (!canMigrate)
+            return; // Skip
+        //
+        // const oldForage = storage.createInstance({
+        //   name: storage.config().name,
+        //   storeName: storage.config().storeName,
+        //   driver: [storage.INDEXEDDB, storage.WEBSQL]
+        // });
+        //
+        // const keys = await oldForage.keys();
+        //
+        // // No data in the odl storage: skip migration
+        // if (isEmptyArray(keys)) {
+        //   // Drop the old instance (not need anymore)
+        //   console.debug(`[platform] Old storage is empty: dropping unused instance {name: '${storage.config().name}', driver: '${oldForage.driver()}'}`);
+        //   await oldForage.dropInstance();
+        // }
+        // // IF some data stored in the OLD storage: start migration
+        // else {
+        //
+        //   const now = Date.now();
+        //   console.info(`[platform] Starting storage migration...`);
+        //
+        //   const toast = await this.showToast({message: 'INFO.DATA_MIGRATION_STARTED', type: 'info', duration: 30000});
+        //   try {
+        //     await StorageUtils.copy(oldForage, storage, {keys, deleteAfterCopy: false});
+        //
+        //     const duration = Date.now() - now;
+        //     setTimeout(() => toast.dismiss(),  Math.max(2000 - duration, 0));
+        //     await this.showToast({message: 'INFO.DATA_MIGRATION_SUCCEED',
+        //       type: 'info',
+        //       showCloseButton: true
+        //     });
+        //     console.info('[platform] Starting storage migration [OK]');
+        //
+        //     // Drop the old instance
+        //     console.info(`[platform] Drop old storage {name: '${storage.config().name}', driver: '${oldForage.driver()}'}`);
+        //     await oldForage.dropInstance();
+        //   }
+        //   catch (err) {
+        //     console.error(err && err.message || err, err);
+        //     await toast.dismiss();
+        //     await this.showToast({message: 'ERROR.DATA_MIGRATION_FAILED',
+        //       type: 'error',
+        //       showCloseButton: true
+        //     });
+        //   }
+        //}
+    }
+    async set(key, value) {
+        if (!this.started)
+            await this.ready();
+        return this._data.set(key, value);
+    }
+    async get(key) {
+        if (!this.started)
+            await this.ready();
+        return this._data.get(key);
+    }
+    async remove(key) {
+        if (!this.started)
+            await this.ready();
+        return this._data.remove(key);
+    }
+    async keys() {
+        if (!this.started)
+            await this.ready();
+        return this._data.keys();
+    }
+    async clear() {
+        if (!this.started)
+            await this.ready();
+        await this._data.clear();
+    }
+    async forEach(iteratorCallback) {
+        if (!this.started)
+            await this.ready();
+        return this._data.forEach(iteratorCallback);
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: StorageService, deps: [{ token: i1.Platform }, { token: i2.Storage }, { token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: StorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root', deps: [ENVIRONMENT]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.Storage }, { type: i3.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../../../src/app/shared/services/storage/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {Storage} from '@ionic/storage-angular';\nimport {IStorage, StorageDrivers} from './storage.utils';\nimport {StartableService} from '../startable-service.class';\nimport {Platform} from '@ionic/angular';\nimport {environment} from '../../../../environments/environment';\nimport {ENVIRONMENT, Environment} from '../../../../environments/environment.class';\nimport * as cordovaSQLiteDriver from 'localforage-cordovasqlitedriver';\n\n@Injectable({\n  providedIn: 'root', deps: [ENVIRONMENT]\n})\nexport class StorageService extends StartableService<Storage>\n  implements IStorage<Storage> {\n\n  get driver(): string | undefined {\n    return this._data?.driver;\n  }\n\n  constructor(private platform: Platform,\n              private storage: Storage,\n              @Inject(ENVIRONMENT) private environment: Environment,\n              ) {\n    super(platform);\n    this._debug = !environment.production;\n    this.start();\n  }\n\n  protected async ngOnStart(): Promise<Storage> {\n    try {\n      console.debug(`[storage-service] Starting... {driverOrder: ${environment.storage?.driverOrder}}`);\n\n      // Define Cordova SQLLite driver\n      await this.storage.defineDriver(cordovaSQLiteDriver);\n\n\n      // Create the storage instance\n      const storage = await this.storage.create();\n\n      // Migrate from old storage\n      await this.migrate(storage);\n\n      console.info(`[storage-service] Started using driver: ${storage?.driver}`);\n      return storage;\n    }\n    catch (err) {\n      console.error('[storage-service] Cannot create storage: ' + (err?.message || err), err);\n    }\n  }\n\n  protected async migrate(storage: Storage) {\n    const canMigrate = storage?.driver === StorageDrivers.SQLLite;\n\n    if (!canMigrate) return; // Skip\n\n    //\n    // const oldForage = storage.createInstance({\n    //   name: storage.config().name,\n    //   storeName: storage.config().storeName,\n    //   driver: [storage.INDEXEDDB, storage.WEBSQL]\n    // });\n    //\n    // const keys = await oldForage.keys();\n    //\n    // // No data in the odl storage: skip migration\n    // if (isEmptyArray(keys)) {\n    //   // Drop the old instance (not need anymore)\n    //   console.debug(`[platform] Old storage is empty: dropping unused instance {name: '${storage.config().name}', driver: '${oldForage.driver()}'}`);\n    //   await oldForage.dropInstance();\n    // }\n    // // IF some data stored in the OLD storage: start migration\n    // else {\n    //\n    //   const now = Date.now();\n    //   console.info(`[platform] Starting storage migration...`);\n    //\n    //   const toast = await this.showToast({message: 'INFO.DATA_MIGRATION_STARTED', type: 'info', duration: 30000});\n    //   try {\n    //     await StorageUtils.copy(oldForage, storage, {keys, deleteAfterCopy: false});\n    //\n    //     const duration = Date.now() - now;\n    //     setTimeout(() => toast.dismiss(),  Math.max(2000 - duration, 0));\n    //     await this.showToast({message: 'INFO.DATA_MIGRATION_SUCCEED',\n    //       type: 'info',\n    //       showCloseButton: true\n    //     });\n    //     console.info('[platform] Starting storage migration [OK]');\n    //\n    //     // Drop the old instance\n    //     console.info(`[platform] Drop old storage {name: '${storage.config().name}', driver: '${oldForage.driver()}'}`);\n    //     await oldForage.dropInstance();\n    //   }\n    //   catch (err) {\n    //     console.error(err && err.message || err, err);\n    //     await toast.dismiss();\n    //     await this.showToast({message: 'ERROR.DATA_MIGRATION_FAILED',\n    //       type: 'error',\n    //       showCloseButton: true\n    //     });\n    //   }\n    //}\n  }\n\n  async set(key: string, value: any) {\n    if (!this.started) await this.ready();\n    return this._data.set(key, value);\n  }\n\n  async get(key: string): Promise<any> {\n    if (!this.started) await this.ready();\n    return this._data.get(key);\n  }\n\n  async remove(key: string) {\n    if (!this.started) await this.ready();\n    return this._data.remove(key);\n  }\n\n  async keys(): Promise<string[]> {\n    if (!this.started) await this.ready();\n    return this._data.keys();\n  }\n\n  async clear() {\n    if (!this.started) await this.ready();\n    await this._data.clear();\n  }\n\n  async forEach(iteratorCallback: (value: any, key: string, iterationNumber: Number) => any): Promise<void> {\n    if (!this.started) await this.ready();\n    return this._data.forEach(iteratorCallback);\n  }\n}\n"]}

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

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+import { Drivers } from '@ionic/storage';
+import * as LocalForage from 'localforage';
+import * as CordovaSQLiteDriver from 'localforage-cordovasqlitedriver';
+export const StorageDrivers = {
+    SQLLite: CordovaSQLiteDriver._driver,
+    SecureStorage: Drivers.SecureStorage,
+    WebSQL: LocalForage.WEBSQL,
+    IndexedDB: Drivers.IndexedDB,
+    LocalStorage: Drivers.LocalStorage
+};
+export const APP_STORAGE = new InjectionToken('Storage');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL3NlcnZpY2VzL3N0b3JhZ2Uvc3RvcmFnZS51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQzdDLE9BQU8sRUFBQyxPQUFPLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssV0FBVyxNQUFNLGFBQWEsQ0FBQztBQUMzQyxPQUFPLEtBQUssbUJBQW1CLE1BQU0saUNBQWlDLENBQUM7QUFhdkUsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHO0lBQzVCLE9BQU8sRUFBRSxtQkFBbUIsQ0FBQyxPQUFPO0lBQ3BDLGFBQWEsRUFBRSxPQUFPLENBQUMsYUFBYTtJQUNwQyxNQUFNLEVBQUUsV0FBVyxDQUFDLE1BQU07SUFDMUIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTO0lBQzVCLFlBQVksRUFBRSxPQUFPLENBQUMsWUFBWTtDQUNuQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksY0FBYyxDQUFXLFNBQVMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0RyaXZlcnN9IGZyb20gJ0Bpb25pYy9zdG9yYWdlJztcbmltcG9ydCAqIGFzIExvY2FsRm9yYWdlIGZyb20gJ2xvY2FsZm9yYWdlJztcbmltcG9ydCAqIGFzIENvcmRvdmFTUUxpdGVEcml2ZXIgZnJvbSAnbG9jYWxmb3JhZ2UtY29yZG92YXNxbGl0ZWRyaXZlcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVN0b3JhZ2U8VCA9IGFueT4ge1xuICByZWFkb25seSBkcml2ZXI6IHN0cmluZztcbiAgcmVhZHkoKTogUHJvbWlzZTxUPlxuICBzZXQoa2V5OiBzdHJpbmcsIHZhbHVlOiBhbnkpOiBQcm9taXNlPHZvaWQ+O1xuICBnZXQoa2V5OiBzdHJpbmcpOiBQcm9taXNlPGFueT47XG4gIHJlbW92ZShrZXk6IHN0cmluZyk6IFByb21pc2U8dm9pZD5cbiAga2V5cygpOiBQcm9taXNlPHN0cmluZ1tdPjtcbiAgY2xlYXIoKTogUHJvbWlzZTx2b2lkPjtcbiAgZm9yRWFjaChpdGVyYXRvckNhbGxiYWNrOiAodmFsdWU6IGFueSwga2V5OiBzdHJpbmcsIGl0ZXJhdGlvbk51bWJlcjogTnVtYmVyKSA9PiBhbnkpOiBQcm9taXNlPHZvaWQ+O1xufVxuXG5leHBvcnQgY29uc3QgU3RvcmFnZURyaXZlcnMgPSB7XG4gIFNRTExpdGU6IENvcmRvdmFTUUxpdGVEcml2ZXIuX2RyaXZlcixcbiAgU2VjdXJlU3RvcmFnZTogRHJpdmVycy5TZWN1cmVTdG9yYWdlLFxuICBXZWJTUUw6IExvY2FsRm9yYWdlLldFQlNRTCxcbiAgSW5kZXhlZERCOiBEcml2ZXJzLkluZGV4ZWREQixcbiAgTG9jYWxTdG9yYWdlOiBEcml2ZXJzLkxvY2FsU3RvcmFnZVxufTtcblxuZXhwb3J0IGNvbnN0IEFQUF9TVE9SQUdFID0gbmV3IEluamVjdGlvblRva2VuPElTdG9yYWdlPignU3RvcmFnZScpO1xuIl19

package/esm2020/src/app/shared/services/translate-context.service.mjs

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { isNil, isNilOrBlank, isNotNilOrBlank } from '../functions';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class TranslateContextService {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    get(key, context, interpolateParams) {
+        // No context: do a normal translate
+        if (!key || !isNil(context))
+            return this.translate.get(key, interpolateParams);
+        // Compute a contextual i18n key, using the context as suffix
+        const contextualKeys = this.contextualKeys(key, context);
+        // Return the contextual translation, or default of not exists
+        return this.translate.get(contextualKeys, interpolateParams)
+            .pipe(map(translations => this.findFirstValid(contextualKeys, translations)));
+    }
+    instant(key, context, interpolateParams) {
+        // No context: do a normal translate
+        if (!key || isNilOrBlank(context))
+            return this.translate.instant(key, interpolateParams);
+        // Compute a contextual i18n key, using the context as suffix
+        const contextualKeys = this.contextualKeys(key, context);
+        const translations = this.translate.instant(contextualKeys, interpolateParams);
+        return this.findFirstValid(contextualKeys, translations);
+    }
+    /**
+     * Compute contextual i18n keys, using the context as suffix.<br>
+     * Suffix can be simple name (like 'aaa' - will return ['<key>.aaa']) or complexe (like 'aaa.bbb' - will return ['<key>.aaa.bbb', '<key>.aaa']
+     *
+     * @param key
+     * @param context
+     * @private
+     */
+    contextualKeys(key, context) {
+        return context.split('.')
+            .filter(isNotNilOrBlank)
+            .reduce((res, item) => {
+            const inheritedContext = res.length > 0 ? (res[res.length - 1] + '.') : '';
+            return res.concat(inheritedContext + item);
+        }, [])
+            .reverse() // Start with children, ends with parent key
+            .map(contextItem => this.contextualKey(key, contextItem))
+            .concat(key);
+    }
+    /**
+     * Compute a contextual i18n key, using the context as suffix
+     *
+     * @param key
+     * @param context
+     * @private
+     */
+    contextualKey(key, context) {
+        // Append a dot on context if missing
+        if (!context.endsWith('.')) {
+            context = context + '.';
+        }
+        // Compute a contextual i18n key, using the context as suffix
+        const parts = key.split('.');
+        return (parts.length === 1)
+            ? `${context}${key}`
+            : parts.slice(0, parts.length - 1).concat(context + parts[parts.length - 1]).join('.');
+    }
+    findFirstValid(keys, translations) {
+        // For eac contextual key: try to find translation, then use the first valid
+        for (let key of keys) {
+            if (translations[key] !== key)
+                return translations[key];
+        }
+        return translations[keys[keys.length - 1]]; // Return the last keys translation
+    }
+}
+TranslateContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TranslateContextService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslateContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TranslateContextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TranslateContextService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdG9yLXNlcnZpY2UuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9zZXJ2aWNlcy92YWxpZGF0b3Itc2VydmljZS5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtWYWxpZGF0b3JTZXJ2aWNlfSBmcm9tICdAZS1pcy9uZ3gtbWF0ZXJpYWwtdGFibGUnO1xuaW1wb3J0IHtBYnN0cmFjdENvbnRyb2wsIFVudHlwZWRGb3JtR3JvdXB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuZXhwb3J0IGludGVyZmFjZSBJVmFsaWRhdG9yU2VydmljZTxUPiBleHRlbmRzIFZhbGlkYXRvclNlcnZpY2Uge1xuXG4gIGdldEZvcm1Hcm91cChkYXRhPzogVCk6IFVudHlwZWRGb3JtR3JvdXA7XG5cbiAgLyoqXG4gICAqIENvbXB1dGUgZXJyb3JzIGZyb20gYSBjb250cm9sc1xuICAgKiBAcGFyYW0gY29udHJvbCBhbnkgY29udHJvbCwgb3IgRm9ybUdyb3VwLCBvciBGb3JtQXJyYXlcbiAgICovXG4gIGdldEkxOG5Gb3JtRXJyb3JzKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IHN0cmluZ1tdO1xuXG59XG4iXX0=

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

@@ -0,0 +1,62 @@
+import { getPropertyByPathAsString, isNotEmptyArray, isNotNil, isNotNilOrBlank, matchUpperCase, propertiesPathComparator, startsWithUpperCase } from './functions';
+export function suggestFromArray(items, value, opts) {
+    if (isNotNil(value) && typeof value === 'object')
+        return { data: [value] };
+    value = (typeof value === 'string' && value !== '*') && value.toUpperCase() || undefined;
+    const keys = opts && (opts.searchAttribute && [opts.searchAttribute] || opts.searchAttributes) || ['label'];
+    if (!items) {
+        return { data: [], total: 0 };
+    }
+    // Filter items
+    let filteredItems = items;
+    if (isNotNilOrBlank(value)) {
+        // If wildcard, search using regexp
+        if (value.indexOf('*') !== -1) {
+            value = value.replace(/[*]+/g, '.*');
+            filteredItems = filteredItems.filter(v => keys.findIndex(key => matchUpperCase(getPropertyByPathAsString(v, key), value)) !== -1);
+        }
+        // Else (no wildcard), search using startsWith
+        else {
+            filteredItems = filteredItems.filter(v => keys.findIndex(key => startsWithUpperCase(getPropertyByPathAsString(v, key), value)) !== -1);
+        }
+    }
+    // Exclude ids
+    if (isNotEmptyArray(opts?.excludedIds)) {
+        filteredItems = filteredItems.filter(v => !opts.excludedIds.includes(+v['id']));
+    }
+    // Sort
+    if (!opts || opts.skipSort !== true) {
+        // Make to copy input items, before sorting (if not yet already done)
+        if (filteredItems === items)
+            filteredItems = filteredItems.slice();
+        // Sort by keys
+        filteredItems.sort(propertiesPathComparator(keys));
+    }
+    const total = filteredItems.length || 0;
+    // Pagination (truncate if need)
+    let pageData = filteredItems;
+    if (opts) {
+        if ((opts.offset || 0) > 0) {
+            pageData = pageData.slice(opts.offset);
+        }
+        if (isNotNil(opts.size) && pageData.length > opts.size) {
+            pageData = pageData.slice(0, opts.size);
+        }
+    }
+    const result = {
+        data: pageData,
+        total
+    };
+    // Add fetch more capability, if total was fetched
+    const nextOffset = (opts && opts.offset || 0) + pageData.length;
+    if (nextOffset < total) {
+        result.fetchMore = async (_) => suggestFromArray(filteredItems, undefined /*OPTIMISATION: already applied*/, {
+            ...opts,
+            offset: nextOffset,
+            skipSort: true,
+            excludedIds: undefined // OPTIMISATION: already filtered
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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