@sumaris-net/ngx-components 2.6.4-alpha5 → 2.6.4-alpha6

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,110 @@
+import { __decorate, __param } from "tslib";
+import { Optional } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+export function isStartableService(data) {
+    return (typeof data?.['start'] === 'function')
+        && (typeof data?.['stop'] === 'function')
+        && (typeof data?.['ready'] === 'function');
+}
+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 function isStartableService(data: any): data is IStartableService {\n  return (typeof data?.['start'] === 'function')\n    && (typeof data?.['stop'] === 'function')\n    && (typeof data?.['ready'] === 'function')\n    ;\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/translate-context.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { of } from 'rxjs';
+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);
+        if (Array.isArray(key)) {
+            if (!key.length)
+                return of();
+            // Observe the first key, then add other
+            return this.get(key[0])
+                .pipe(map(translation => {
+                return key.slice(1) // Skip 1, because we already have it
+                    .reduce((map, k) => {
+                    map[k] = this.instant(k, context);
+                    return map;
+                }, 
+                // Init with the first value
+                {
+                    [key[0]]: translation
+                });
+            }));
+        }
+        // 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);
+        if (Array.isArray(key)) {
+            return key.reduce((map, k) => {
+                map[k] = this.instant(k, context);
+                return map;
+            }, {});
+        }
+        // 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.3.0", ngImport: i0, type: TranslateContextService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslateContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TranslateContextService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TranslateContextService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate-context.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/translate-context.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {TranslateService} from '@ngx-translate/core';\nimport {map, mergeMap} from 'rxjs/operators';\nimport {Observable, of} from 'rxjs';\nimport {isNil, isNilOrBlank, isNotNilOrBlank} from '../functions';\n\n\n@Injectable({providedIn: 'root'})\nexport class TranslateContextService {\n\n  constructor(\n    protected translate: TranslateService\n  ) {\n  }\n\n\n  get(key: string|string[], context?: string, interpolateParams?: Object): Observable<any> {\n    // No context: do a normal translate\n    if (!key || !isNil(context)) return this.translate.get(key, interpolateParams);\n\n    if (Array.isArray(key)) {\n      if (!key.length) return of();\n      // Observe the first key, then add other\n      return this.get(key[0])\n        .pipe(map(\n          translation => {\n                return key.slice(1) // Skip 1, because we already have it\n                  .reduce((map, k) => {\n                    map[k] = this.instant(k, context);\n                    return map;\n                  },\n                  // Init with the first value\n                  {\n                    [key[0]]: translation\n                  });\n          })\n        );\n    }\n\n    // Compute a contextual i18n key, using the context as suffix\n    const contextualKeys = this.contextualKeys(key, context);\n\n    // Return the contextual translation, or default of not exists\n    return this.translate.get(contextualKeys, interpolateParams)\n      .pipe(\n        map(translations => this.findFirstValid(contextualKeys, translations))\n      );\n  }\n\n  instant(key: string|string[], context?: string, interpolateParams?: Object): any {\n    // No context: do a normal translate\n    if (!key || isNilOrBlank(context)) return this.translate.instant(key, interpolateParams);\n\n    if (Array.isArray(key)) {\n      return key.reduce((map, k) => {\n        map[k] = this.instant(k, context);\n        return map;\n      }, {});\n    }\n\n    // Compute a contextual i18n key, using the context as suffix\n    const contextualKeys = this.contextualKeys(key, context);\n    const translations = this.translate.instant(contextualKeys, interpolateParams);\n\n    return this.findFirstValid(contextualKeys, translations);\n  }\n\n  /**\n   * Compute contextual i18n keys, using the context as suffix.<br>\n   * Suffix can be simple name (like 'aaa' - will return ['<key>.aaa']) or complexe (like 'aaa.bbb' - will return ['<key>.aaa.bbb', '<key>.aaa']\n   *\n   * @param key\n   * @param context\n   * @private\n   */\n  contextualKeys(key: string, context: string): string[] {\n    return context.split('.')\n      .filter(isNotNilOrBlank)\n      .reduce((res, item) => {\n        const inheritedContext = res.length > 0 ? (res[res.length - 1] + '.') : '';\n        return res.concat( inheritedContext + item)\n      }, [])\n      .reverse() // Start with children, ends with parent key\n      .map(contextItem => this.contextualKey(key, contextItem))\n      .concat(key)\n  }\n\n  /**\n   * Compute a contextual i18n key, using the context as suffix\n   *\n   * @param key\n   * @param context\n   * @private\n   */\n  contextualKey(key: string, context: string): string {\n\n    // Append a dot on context if missing\n    if (!context.endsWith('.')) {\n      context = context + '.';\n    }\n\n    // Compute a contextual i18n key, using the context as suffix\n    const parts = key.split('.');\n    return (parts.length === 1)\n      ? `${context}${key}`\n      : parts.slice(0, parts.length - 1).concat(context + parts[parts.length - 1]).join('.');\n  }\n\n  private findFirstValid(keys: string[], translations: { [key: string]: string }): string {\n    // For eac contextual key: try to find translation, then use the first valid\n    for (let key of keys) {\n      if (translations[key] !== key) return translations[key];\n    }\n    return translations[keys[keys.length-1]]; // Return the last keys translation\n  }\n}\n"]}

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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

package/esm2020/src/app/shared/shared-routing.module.mjs

@@ -0,0 +1,70 @@
+import { Injectable, NgModule } from '@angular/core';
+import { RouteReuseStrategy, RouterModule } from '@angular/router';
+import { IonicRouteStrategy } from '@ionic/angular';
+import { ComponentDirtyGuard } from './guard/component-dirty.guard';
+import { isNil, isNotNil } from './functions';
+import * as i0 from "@angular/core";
+export class CustomReuseStrategy extends IonicRouteStrategy {
+    /**
+     * Force to reuse the route when:
+     *  - path change from [/new] -> [/:id]
+     *  - or path change from [/new] -> [/new?id=:id]
+     * @param future
+     * @param curr
+     */
+    shouldReuseRoute(future, curr) {
+        const reuse = super.shouldReuseRoute(future, curr);
+        // Is sam route config
+        if (!reuse && future.routeConfig && future.routeConfig === curr.routeConfig) {
+            // Read the parameter name, where id is stored
+            const pathIdParam = future.routeConfig.data && future.routeConfig.data.pathIdParam || 'id';
+            // Read the current route id
+            const currId = curr.params[pathIdParam] === 'new'
+                ? (curr.queryParams[pathIdParam] || curr.queryParams['id'] || 'new') // e.g. path like '/new/?id=<ID>'
+                : curr.params[pathIdParam]; // e.g. path like '/<ID>'
+            // Read the future route id
+            const futureId = future.params[pathIdParam] === 'new'
+                ? (future.queryParams[pathIdParam] || future.queryParams['id'] || 'new') // e.g. path like '/new/?id=<ID>'
+                : future.params[pathIdParam]; // e.g. path like '/<ID>'
+            // Reuse if same ID, using a futureId, if exists
+            if (isNotNil(futureId)) {
+                // Allow reuse when changing from /new to /new?id=:id
+                if (currId === 'new' && isNil(curr.queryParams[pathIdParam]) && future.params[pathIdParam] === 'new' && isNotNil(future.queryParams[pathIdParam])) {
+                    return true;
+                }
+                // Allow reuse same id, expect when expected '/new'
+                return futureId !== 'new' && futureId === currId;
+            }
+        }
+        return reuse;
+    }
+}
+CustomReuseStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CustomReuseStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+CustomReuseStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CustomReuseStrategy });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CustomReuseStrategy, decorators: [{
+            type: Injectable
+        }] });
+export class SharedRoutingModule {
+    constructor() {
+        console.debug('[shared-routing] Creating module...');
+    }
+}
+SharedRoutingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SharedRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SharedRoutingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: SharedRoutingModule, imports: [RouterModule] });
+SharedRoutingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SharedRoutingModule, providers: [
+        { provide: RouteReuseStrategy, useClass: CustomReuseStrategy },
+        { provide: ComponentDirtyGuard, useClass: ComponentDirtyGuard }
+    ], imports: [RouterModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SharedRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        RouterModule
+                    ],
+                    providers: [
+                        { provide: RouteReuseStrategy, useClass: CustomReuseStrategy },
+                        { provide: ComponentDirtyGuard, useClass: ComponentDirtyGuard }
+                    ]
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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