@sumaris-net/ngx-components 18.12.0 → 18.12.1

package/esm2022/src/app/shared/version/versions.mjs

@@ -0,0 +1,81 @@
+const regexp = {
+    POSITIVE_INTEGER: /^\d+$/,
+    VERSION_PART_REGEXP: /^[0-9]+|alpha[0-9]+|beta[0-9]+|rc[0-9]+|[0-9]+-SNAPSHOT$/,
+};
+export class VersionUtils {
+    static compare = compareVersionNumbers;
+    static isCompatible = isVersionCompatible;
+    static isSame = isSameVersion;
+}
+/**
+ * Compare two software version numbers (e.g. 1.7.1)
+ * Returns:
+ *
+ *  0 if they're identical
+ *  negative if v1 < v2
+ *  positive if v1 > v2
+ *  Nan if they in the wrong format
+ *
+ *  E.g.:
+ *
+ *  assert(version_number_compare("1.7.1", "1.6.10") > 0);
+ *  assert(version_number_compare("1.7.1", "1.7.10") < 0);
+ *
+ *  "Unit tests": http://jsfiddle.net/ripper234/Xv9WL/28/
+ *
+ *  Taken from http://stackoverflow.com/a/6832721/11236
+ */
+export function compareVersionNumbers(v1, v2) {
+    const v1parts = v1.split('.');
+    const v2parts = v2.split('.');
+    // First, validate both numbers are true version numbers
+    if (!validateParts(v1parts) || !validateParts(v2parts)) {
+        return NaN;
+    }
+    for (let i = 0; i < v1parts.length; ++i) {
+        if (v2parts.length === i) {
+            return 1;
+        }
+        if (v1parts[i] === v2parts[i]) {
+            continue;
+        }
+        if (v1parts[i] > v2parts[i]) {
+            return 1;
+        }
+        return -1;
+    }
+    if (v1parts.length !== v2parts.length) {
+        return -1;
+    }
+    return 0;
+}
+function validateParts(parts) {
+    for (let i = 0; i < parts.length; i++) {
+        let isNumber = regexp.POSITIVE_INTEGER.test(parts[i]);
+        // First part MUST be an integer
+        if (i === 0 && !isNumber)
+            return false;
+        // If not integer, should be 'alpha', 'beta', etc.
+        if (!isNumber) {
+            if (!regexp.VERSION_PART_REGEXP.test(parts[i]))
+                return false;
+            // Remove '-SNAPSHOT', as it should never be in prod
+            parts[i] = parts[i].replace('-SNAPSHOT', '');
+            // Check again if numeric
+            isNumber = regexp.POSITIVE_INTEGER.test(parts[i]);
+        }
+        // Convert string to int (need by compare operators)
+        if (isNumber)
+            parts[i] = parseInt(parts[i]);
+    }
+    return true;
+}
+export function isVersionCompatible(minVersion, actualVersion) {
+    // DEV ONLY
+    //console.debug(`[http] Checking actual version {${actualVersion}} is compatible with min expected version {${minVersion}}`);
+    return compareVersionNumbers(minVersion, actualVersion) <= 0;
+}
+export function isSameVersion(v1, v2) {
+    return compareVersionNumbers(v1, v2) === 0;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC92ZXJzaW9uL3ZlcnNpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sTUFBTSxHQUFHO0lBQ2IsZ0JBQWdCLEVBQUUsT0FBTztJQUN6QixtQkFBbUIsRUFBRSwwREFBMEQ7Q0FDaEYsQ0FBQztBQUVGLE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLE1BQU0sQ0FBQyxPQUFPLEdBQUcscUJBQXFCLENBQUM7SUFDdkMsTUFBTSxDQUFDLFlBQVksR0FBRyxtQkFBbUIsQ0FBQztJQUMxQyxNQUFNLENBQUMsTUFBTSxHQUFHLGFBQWEsQ0FBQzs7QUFHaEM7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUFDLEVBQUUsRUFBRSxFQUFFO0lBQzFDLE1BQU0sT0FBTyxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDOUIsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUU5Qix3REFBd0Q7SUFFeEQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1FBQ3ZELE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUVELEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFDeEMsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3pCLE9BQU8sQ0FBQyxDQUFDO1FBQ1gsQ0FBQztRQUVELElBQUksT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQzlCLFNBQVM7UUFDWCxDQUFDO1FBQ0QsSUFBSSxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDNUIsT0FBTyxDQUFDLENBQUM7UUFDWCxDQUFDO1FBQ0QsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNaLENBQUM7SUFFRCxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ3RDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDWixDQUFDO0lBRUQsT0FBTyxDQUFDLENBQUM7QUFDWCxDQUFDO0FBRUQsU0FBUyxhQUFhLENBQUMsS0FBSztJQUMxQixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ3RDLElBQUksUUFBUSxHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdEQsZ0NBQWdDO1FBQ2hDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFFBQVE7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUN2QyxrREFBa0Q7UUFDbEQsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUFFLE9BQU8sS0FBSyxDQUFDO1lBQzdELG9EQUFvRDtZQUNwRCxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDN0MseUJBQXlCO1lBQ3pCLFFBQVEsR0FBRyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3BELENBQUM7UUFFRCxvREFBb0Q7UUFDcEQsSUFBSSxRQUFRO1lBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQsTUFBTSxVQUFVLG1CQUFtQixDQUFDLFVBQVUsRUFBRSxhQUFhO0lBQzNELFdBQVc7SUFDWCw2SEFBNkg7SUFDN0gsT0FBTyxxQkFBcUIsQ0FBQyxVQUFVLEVBQUUsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQy9ELENBQUM7QUFFRCxNQUFNLFVBQVUsYUFBYSxDQUFDLEVBQUUsRUFBRSxFQUFFO0lBQ2xDLE9BQU8scUJBQXFCLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUM3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgcmVnZXhwID0ge1xuICBQT1NJVElWRV9JTlRFR0VSOiAvXlxcZCskLyxcbiAgVkVSU0lPTl9QQVJUX1JFR0VYUDogL15bMC05XSt8YWxwaGFbMC05XSt8YmV0YVswLTldK3xyY1swLTldK3xbMC05XSstU05BUFNIT1QkLyxcbn07XG5cbmV4cG9ydCBjbGFzcyBWZXJzaW9uVXRpbHMge1xuICBzdGF0aWMgY29tcGFyZSA9IGNvbXBhcmVWZXJzaW9uTnVtYmVycztcbiAgc3RhdGljIGlzQ29tcGF0aWJsZSA9IGlzVmVyc2lvbkNvbXBhdGlibGU7XG4gIHN0YXRpYyBpc1NhbWUgPSBpc1NhbWVWZXJzaW9uO1xufVxuXG4vKipcbiAqIENvbXBhcmUgdHdvIHNvZnR3YXJlIHZlcnNpb24gbnVtYmVycyAoZS5nLiAxLjcuMSlcbiAqIFJldHVybnM6XG4gKlxuICogIDAgaWYgdGhleSdyZSBpZGVudGljYWxcbiAqICBuZWdhdGl2ZSBpZiB2MSA8IHYyXG4gKiAgcG9zaXRpdmUgaWYgdjEgPiB2MlxuICogIE5hbiBpZiB0aGV5IGluIHRoZSB3cm9uZyBmb3JtYXRcbiAqXG4gKiAgRS5nLjpcbiAqXG4gKiAgYXNzZXJ0KHZlcnNpb25fbnVtYmVyX2NvbXBhcmUoXCIxLjcuMVwiLCBcIjEuNi4xMFwiKSA+IDApO1xuICogIGFzc2VydCh2ZXJzaW9uX251bWJlcl9jb21wYXJlKFwiMS43LjFcIiwgXCIxLjcuMTBcIikgPCAwKTtcbiAqXG4gKiAgXCJVbml0IHRlc3RzXCI6IGh0dHA6Ly9qc2ZpZGRsZS5uZXQvcmlwcGVyMjM0L1h2OVdMLzI4L1xuICpcbiAqICBUYWtlbiBmcm9tIGh0dHA6Ly9zdGFja292ZXJmbG93LmNvbS9hLzY4MzI3MjEvMTEyMzZcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvbXBhcmVWZXJzaW9uTnVtYmVycyh2MSwgdjIpIHtcbiAgY29uc3QgdjFwYXJ0cyA9IHYxLnNwbGl0KCcuJyk7XG4gIGNvbnN0IHYycGFydHMgPSB2Mi5zcGxpdCgnLicpO1xuXG4gIC8vIEZpcnN0LCB2YWxpZGF0ZSBib3RoIG51bWJlcnMgYXJlIHRydWUgdmVyc2lvbiBudW1iZXJzXG5cbiAgaWYgKCF2YWxpZGF0ZVBhcnRzKHYxcGFydHMpIHx8ICF2YWxpZGF0ZVBhcnRzKHYycGFydHMpKSB7XG4gICAgcmV0dXJuIE5hTjtcbiAgfVxuXG4gIGZvciAobGV0IGkgPSAwOyBpIDwgdjFwYXJ0cy5sZW5ndGg7ICsraSkge1xuICAgIGlmICh2MnBhcnRzLmxlbmd0aCA9PT0gaSkge1xuICAgICAgcmV0dXJuIDE7XG4gICAgfVxuXG4gICAgaWYgKHYxcGFydHNbaV0gPT09IHYycGFydHNbaV0pIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cbiAgICBpZiAodjFwYXJ0c1tpXSA+IHYycGFydHNbaV0pIHtcbiAgICAgIHJldHVybiAxO1xuICAgIH1cbiAgICByZXR1cm4gLTE7XG4gIH1cblxuICBpZiAodjFwYXJ0cy5sZW5ndGggIT09IHYycGFydHMubGVuZ3RoKSB7XG4gICAgcmV0dXJuIC0xO1xuICB9XG5cbiAgcmV0dXJuIDA7XG59XG5cbmZ1bmN0aW9uIHZhbGlkYXRlUGFydHMocGFydHMpIHtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBwYXJ0cy5sZW5ndGg7IGkrKykge1xuICAgIGxldCBpc051bWJlciA9IHJlZ2V4cC5QT1NJVElWRV9JTlRFR0VSLnRlc3QocGFydHNbaV0pO1xuICAgIC8vIEZpcnN0IHBhcnQgTVVTVCBiZSBhbiBpbnRlZ2VyXG4gICAgaWYgKGkgPT09IDAgJiYgIWlzTnVtYmVyKSByZXR1cm4gZmFsc2U7XG4gICAgLy8gSWYgbm90IGludGVnZXIsIHNob3VsZCBiZSAnYWxwaGEnLCAnYmV0YScsIGV0Yy5cbiAgICBpZiAoIWlzTnVtYmVyKSB7XG4gICAgICBpZiAoIXJlZ2V4cC5WRVJTSU9OX1BBUlRfUkVHRVhQLnRlc3QocGFydHNbaV0pKSByZXR1cm4gZmFsc2U7XG4gICAgICAvLyBSZW1vdmUgJy1TTkFQU0hPVCcsIGFzIGl0IHNob3VsZCBuZXZlciBiZSBpbiBwcm9kXG4gICAgICBwYXJ0c1tpXSA9IHBhcnRzW2ldLnJlcGxhY2UoJy1TTkFQU0hPVCcsICcnKTtcbiAgICAgIC8vIENoZWNrIGFnYWluIGlmIG51bWVyaWNcbiAgICAgIGlzTnVtYmVyID0gcmVnZXhwLlBPU0lUSVZFX0lOVEVHRVIudGVzdChwYXJ0c1tpXSk7XG4gICAgfVxuXG4gICAgLy8gQ29udmVydCBzdHJpbmcgdG8gaW50IChuZWVkIGJ5IGNvbXBhcmUgb3BlcmF0b3JzKVxuICAgIGlmIChpc051bWJlcikgcGFydHNbaV0gPSBwYXJzZUludChwYXJ0c1tpXSk7XG4gIH1cbiAgcmV0dXJuIHRydWU7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1ZlcnNpb25Db21wYXRpYmxlKG1pblZlcnNpb24sIGFjdHVhbFZlcnNpb24pOiBib29sZWFuIHtcbiAgLy8gREVWIE9OTFlcbiAgLy9jb25zb2xlLmRlYnVnKGBbaHR0cF0gQ2hlY2tpbmcgYWN0dWFsIHZlcnNpb24geyR7YWN0dWFsVmVyc2lvbn19IGlzIGNvbXBhdGlibGUgd2l0aCBtaW4gZXhwZWN0ZWQgdmVyc2lvbiB7JHttaW5WZXJzaW9ufX1gKTtcbiAgcmV0dXJuIGNvbXBhcmVWZXJzaW9uTnVtYmVycyhtaW5WZXJzaW9uLCBhY3R1YWxWZXJzaW9uKSA8PSAwO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNTYW1lVmVyc2lvbih2MSwgdjIpOiBib29sZWFuIHtcbiAgcmV0dXJuIGNvbXBhcmVWZXJzaW9uTnVtYmVycyh2MSwgdjIpID09PSAwO1xufVxuIl19

package/esm2022/src/app/social/job/job.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { SharedModule } from '../../shared/shared.module';
+import { JobProgressionIcon } from './progression/job-progression.icon';
+import { JobProgressionList } from './progression/job-progression.list';
+import { JobProgressionComponent } from './progression/job-progression.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class JobModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: JobModule, declarations: [JobProgressionIcon, JobProgressionList, JobProgressionComponent], imports: [CommonModule, SharedModule, i1.TranslateModule], exports: [JobProgressionIcon, JobProgressionList, JobProgressionComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobModule, imports: [CommonModule, SharedModule, TranslateModule.forChild()] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SharedModule, TranslateModule.forChild()],
+                    declarations: [JobProgressionIcon, JobProgressionList, JobProgressionComponent],
+                    exports: [JobProgressionIcon, JobProgressionList, JobProgressionComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/social/job/progression/job-progression.component.mjs

@@ -0,0 +1,35 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { RxState } from '@rx-angular/state';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@rx-angular/template/push";
+export class JobProgressionComponent extends RxState {
+    showName = true;
+    jobProgression$;
+    name$ = this.select('name');
+    message$ = this.select('message');
+    value$ = this.select('value');
+    type$ = this.select('type');
+    constructor() {
+        super();
+    }
+    ngOnInit() {
+        this.connect('name', this.jobProgression$.pipe(map((value) => value.name)));
+        this.connect('message', this.jobProgression$.pipe(map((value) => value.message)));
+        this.connect('value', this.jobProgression$.pipe(map((value) => (value.total > 0 ? value.current / value.total : undefined))));
+        this.connect('type', this.jobProgression$.pipe(map((value) => (value.total > 0 ? 'determinate' : 'indeterminate'))));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: JobProgressionComponent, selector: "app-job-progression-component", inputs: { showName: "showName", jobProgression$: "jobProgression$" }, usesInheritance: true, ngImport: i0, template: "<ion-item class=\"ion-item-job-progression\">\n  <ion-grid class=\"ion-no-margin\">\n    <ion-row *ngIf=\"showName\" class=\"name\">\n      <ion-col>\n        {{ name$ | push }}\n      </ion-col>\n    </ion-row>\n    <ion-row class=\"message\">\n      <ion-col>\n        {{ message$ | push }}\n      </ion-col>\n    </ion-row>\n    <ion-row class=\"progress-bar\">\n      <ion-col>\n        <ion-progress-bar [value]=\"value$ | push\" [type]=\"type$ | push\"></ion-progress-bar>\n      </ion-col>\n    </ion-row>\n  </ion-grid>\n</ion-item>\n", styles: [".ion-item-job-progression{font-size:.9em}.ion-item-job-progression .message{font-style:italic}.ion-item-job-progression .progress-bar{margin-top:5px;margin-bottom:5px}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: i2.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: i2.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i2.IonProgressBar, selector: "ion-progress-bar", inputs: ["buffer", "color", "mode", "reversed", "type", "value"] }, { kind: "component", type: i2.IonRow, selector: "ion-row" }, { kind: "pipe", type: i3.RxPush, name: "push" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-job-progression-component', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ion-item class=\"ion-item-job-progression\">\n  <ion-grid class=\"ion-no-margin\">\n    <ion-row *ngIf=\"showName\" class=\"name\">\n      <ion-col>\n        {{ name$ | push }}\n      </ion-col>\n    </ion-row>\n    <ion-row class=\"message\">\n      <ion-col>\n        {{ message$ | push }}\n      </ion-col>\n    </ion-row>\n    <ion-row class=\"progress-bar\">\n      <ion-col>\n        <ion-progress-bar [value]=\"value$ | push\" [type]=\"type$ | push\"></ion-progress-bar>\n      </ion-col>\n    </ion-row>\n  </ion-grid>\n</ion-item>\n", styles: [".ion-item-job-progression{font-size:.9em}.ion-item-job-progression .message{font-style:italic}.ion-item-job-progression .progress-bar{margin-top:5px;margin-bottom:5px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { showName: [{
+                type: Input
+            }], jobProgression$: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/social/job/progression/job-progression.icon.mjs

@@ -0,0 +1,235 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, } from '@angular/core';
+import { APP_JOB_PROGRESSION_SERVICE } from './job-progression.service';
+import { JobProgression } from './job-progression.model';
+import { BehaviorSubject, delay, of, Subscription, switchMap } from 'rxjs';
+import { arraySize, isNil, remove, toBoolean, toNumber } from '../../../shared/functions';
+import { filter, map, tap } from 'rxjs/operators';
+import { JobProgressionList } from './job-progression.list';
+import { RxState } from '@rx-angular/state';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@rx-angular/template/if";
+import * as i3 from "@rx-angular/template/let";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/progress-spinner";
+import * as i7 from "@angular/material/badge";
+import * as i8 from "@ngx-translate/core";
+import * as i9 from "@rx-angular/template/push";
+export class JobProgressionIcon extends RxState {
+    jobProgressionService;
+    popoverController;
+    cd;
+    debug = false;
+    titleI18n = 'SOCIAL.JOB.PROGRESSION.TITLE';
+    options;
+    autoHide;
+    headerActions;
+    jobFinished = new EventEmitter();
+    disabled = true;
+    color = 'accent';
+    jobProgressions$ = this.select('jobProgressions');
+    jobCount$ = this.select('jobCount');
+    visible$ = this.select('visible');
+    mode$ = this.select('mode');
+    value$ = this.select('value');
+    autoHideDelay;
+    autoRemove;
+    autoRemoveDelay;
+    _listPopover;
+    _subscriptions = new Subscription();
+    _subscriptionsById = {};
+    _logPrefix = '[job-progression] ';
+    constructor(jobProgressionService, popoverController, cd) {
+        super();
+        this.jobProgressionService = jobProgressionService;
+        this.popoverController = popoverController;
+        this.cd = cd;
+    }
+    get jobProgressions() {
+        return this.get('jobProgressions');
+    }
+    ngOnInit() {
+        if (isNil(this.jobProgressionService)) {
+            console.warn(`${this._logPrefix}No service injected`);
+        }
+        // parse options
+        this.autoHide = toBoolean(this.autoHide, this.options?.autoHide || false);
+        this.set({ visible: !this.autoHide, mode: 'determinate', value: 0 });
+        this.autoHideDelay = toNumber(this.options?.autoHideDelay, 1000);
+        this.autoRemove = toBoolean(this.options?.autoRemove, true);
+        this.autoRemoveDelay = toNumber(this.options?.autoRemoveDelay, 1000);
+        if (this.jobProgressionService) {
+            this.connect('jobProgressions', this.jobProgressionService.watchAll(), (state, items) => {
+                const existingJobIds = state.jobProgressions?.map((job) => job.value.id) || [];
+                const result = (items || []).map((item) => {
+                    remove(existingJobIds, (id) => id === item.id);
+                    // Add job to listen
+                    return this.startListenJob(item.id, item);
+                });
+                // Remove old jobs
+                if (existingJobIds.length > 0) {
+                    existingJobIds.forEach((id) => this.stopListenJob(id, { emitEvent: false }));
+                }
+                return result;
+            });
+        }
+        this.connect('jobCount', this.jobProgressions$.pipe(map((jobs) => jobs?.length || 0)));
+        this.connect('visible', this.jobCount$.pipe(map((jobCount) => jobCount > 0), switchMap((hasJob) => hasJob
+            ? of(true)
+            : of(false).pipe(filter(() => this.autoHide), delay(this.autoHideDelay), tap(() => {
+                if (this._listPopover)
+                    this._listPopover.dismiss();
+            })))));
+    }
+    startListenJob(id, job) {
+        if (isNil(this.jobProgressionService)) {
+            console.warn(`${this._logPrefix}No service injected. Can't add a job`);
+            return;
+        }
+        if (isNil(id)) {
+            console.error(`${this._logPrefix}Missing required argument 'id'. Cannot listen changes !`);
+            return;
+        }
+        let result = this.getProgression(id);
+        if (result) {
+            //console.warn(`${this._logPrefix}Job (id=${id}) already present`);
+            return result;
+        }
+        if (this.debug) {
+            console.debug(`${this._logPrefix}Add job id=${id}`);
+        }
+        // Adding empty job progression
+        result = new BehaviorSubject(job || new JobProgression(id));
+        this.disabled = false;
+        const sub = this.jobProgressionService
+            .listenChanges(id)
+            .pipe(filter((progression) => {
+            if (id !== progression.id) {
+                console.error(`${this._logPrefix}Job progression (id=${progression.id}) doesn't match expected job (id=${id})`);
+                return false;
+            }
+            return true;
+        }), map((progression) => {
+            // update current
+            result.next(progression);
+            if (this.debug) {
+                console.debug(`${this._logPrefix}Progression updated id=${id}`, progression);
+            }
+            return progression;
+        }))
+            .subscribe((progression) => {
+            // update value
+            this.updateValue();
+            // job finished
+            if (progression.total > 0 && progression.current === progression.total) {
+                if (this.debug) {
+                    console.debug(`${this._logPrefix}Finished job id=${progression.id}`);
+                }
+                // emit event
+                this.jobFinished.emit(progression.id);
+                if (this.autoRemove) {
+                    setTimeout(() => {
+                        this.stopListenJob(progression.id);
+                    }, this.autoRemoveDelay);
+                }
+            }
+        });
+        this._subscriptionsById[id] = sub;
+        this._subscriptions.add(sub);
+        return result;
+    }
+    stopListenJob(id, opts) {
+        if (this.debug) {
+            console.debug(`${this._logPrefix}Remove job id=${id}`);
+        }
+        const sub = this._subscriptionsById[id];
+        if (sub) {
+            this._subscriptions.remove(sub);
+            sub.unsubscribe();
+        }
+        // Remove job from service
+        this.jobProgressionService.removeJob(id);
+        if (!opts?.emitEvent !== false) {
+            this.updateValue();
+        }
+    }
+    getProgression(id) {
+        return this.jobProgressions?.find((progression) => progression.value.id === id);
+    }
+    updateValue() {
+        if (this.debug) {
+            console.debug(`${this._logPrefix}Updating value`);
+        }
+        let value = 0;
+        const nbProgression = arraySize(this.jobProgressions);
+        let allIndeterminate = nbProgression > 0;
+        if (nbProgression) {
+            this.jobProgressions
+                .map((subject) => subject.value)
+                .forEach((progression) => {
+                const indeterminate = progression.total === 0;
+                allIndeterminate = allIndeterminate && indeterminate;
+                if (!indeterminate) {
+                    value = value + (progression.current * 100) / progression.total;
+                }
+            });
+        }
+        this.set({ mode: allIndeterminate ? 'indeterminate' : 'determinate', value: nbProgression > 0 ? value / nbProgression : 0 });
+        if (this.debug) {
+            console.debug(`${this._logPrefix}Setting value=${this.get('value')}, mode=${this.get('mode')}`);
+        }
+        this.markForCheck();
+    }
+    async showList(event) {
+        this._listPopover = await this.popoverController.create({
+            component: JobProgressionList,
+            componentProps: {
+                titleI18n: this.titleI18n,
+                jobProgressions: this.jobProgressions$,
+                headerActions: this.headerActions,
+            },
+            backdropDismiss: true,
+            keyboardClose: true,
+            event,
+            translucent: true,
+            cssClass: 'popover-large',
+        });
+        await this._listPopover.present();
+        await this._listPopover.onDidDismiss();
+        this._listPopover = undefined;
+    }
+    markForCheck() {
+        this.cd.markForCheck();
+    }
+    ngOnDestroy() {
+        if (this.debug) {
+            console.debug(`${this._logPrefix}Destroying`);
+        }
+        this._subscriptions.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionIcon, deps: [{ token: APP_JOB_PROGRESSION_SERVICE, optional: true }, { token: i1.PopoverController }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: JobProgressionIcon, selector: "app-job-progression-icon", inputs: { debug: "debug", titleI18n: "titleI18n", options: "options", autoHide: "autoHide", headerActions: "headerActions" }, outputs: { jobFinished: "jobFinished" }, usesInheritance: true, ngImport: i0, template: "<button\n  #button\n  mat-icon-button\n  [title]=\"titleI18n | translate\"\n  [disabled]=\"disabled\"\n  *rxIf=\"visible$\"\n  (click)=\"showList($event)\"\n>\n  <mat-icon\n    *rxLet=\"jobCount$; let jobCount\"\n    [matBadge]=\"jobCount\"\n    [matBadgeHidden]=\"!jobCount\"\n    matBadgeColor=\"accent\"\n    matBadgeSize=\"small\"\n    matBadgePosition=\"above after\"\n    aria-hidden=\"false\"\n  >\n    {{ disabled || jobCount ? 'schedule' : 'task_alt' }}\n  </mat-icon>\n  <mat-spinner\n    #spinner\n    *rxIf=\"jobCount$\"\n    class=\"floating-spinner\"\n    [color]=\"color\"\n    [mode]=\"mode$ | push\"\n    [value]=\"value$ | push\"\n    diameter=\"30\"\n    strokeWidth=\"3\"\n  ></mat-spinner>\n</button>\n", styles: [".floating-spinner{position:absolute;height:24px!important;width:24px!important;top:12px;left:12px}\n"], dependencies: [{ kind: "directive", type: i2.RxIf, selector: "[rxIf]", inputs: ["rxIf", "rxIfStrategy", "rxIfElse", "rxIfThen", "rxIfSuspense", "rxIfComplete", "rxIfError", "rxIfContextTrigger", "rxIfNextTrigger", "rxIfSuspenseTrigger", "rxIfErrorTrigger", "rxIfCompleteTrigger", "rxIfParent", "rxIfPatchZone", "rxIfRenderCallback"] }, { kind: "directive", type: i3.RxLet, selector: "[rxLet]", inputs: ["rxLet", "rxLetStrategy", "rxLetComplete", "rxLetError", "rxLetSuspense", "rxLetContextTrigger", "rxLetCompleteTrigger", "rxLetErrorTrigger", "rxLetSuspenseTrigger", "rxLetNextTrigger", "rxLetRenderCallback", "rxLetParent", "rxLetPatchZone"], outputs: ["rendered"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i5.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "component", type: i6.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: i7.MatBadge, selector: "[matBadge]", inputs: ["matBadgeColor", "matBadgeOverlap", "matBadgeDisabled", "matBadgePosition", "matBadge", "matBadgeDescription", "matBadgeSize", "matBadgeHidden"] }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }, { kind: "pipe", type: i9.RxPush, name: "push" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionIcon, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-job-progression-icon', changeDetection: ChangeDetectionStrategy.OnPush, template: "<button\n  #button\n  mat-icon-button\n  [title]=\"titleI18n | translate\"\n  [disabled]=\"disabled\"\n  *rxIf=\"visible$\"\n  (click)=\"showList($event)\"\n>\n  <mat-icon\n    *rxLet=\"jobCount$; let jobCount\"\n    [matBadge]=\"jobCount\"\n    [matBadgeHidden]=\"!jobCount\"\n    matBadgeColor=\"accent\"\n    matBadgeSize=\"small\"\n    matBadgePosition=\"above after\"\n    aria-hidden=\"false\"\n  >\n    {{ disabled || jobCount ? 'schedule' : 'task_alt' }}\n  </mat-icon>\n  <mat-spinner\n    #spinner\n    *rxIf=\"jobCount$\"\n    class=\"floating-spinner\"\n    [color]=\"color\"\n    [mode]=\"mode$ | push\"\n    [value]=\"value$ | push\"\n    diameter=\"30\"\n    strokeWidth=\"3\"\n  ></mat-spinner>\n</button>\n", styles: [".floating-spinner{position:absolute;height:24px!important;width:24px!important;top:12px;left:12px}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_JOB_PROGRESSION_SERVICE]
+                }] }, { type: i1.PopoverController }, { type: i0.ChangeDetectorRef }], propDecorators: { debug: [{
+                type: Input
+            }], titleI18n: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], autoHide: [{
+                type: Input
+            }], headerActions: [{
+                type: Input
+            }], jobFinished: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-progression.icon.js","sourceRoot":"","sources":["../../../../../../../src/app/social/job/progression/job-progression.icon.ts","../../../../../../../src/app/social/job/progression/job-progression.icon.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n} from '@angular/core';\nimport { ThemePalette } from '@angular/material/core';\nimport { APP_JOB_PROGRESSION_SERVICE, IJobProgressionService } from './job-progression.service';\nimport { JobProgression } from './job-progression.model';\nimport { BehaviorSubject, delay, of, Subscription, switchMap } from 'rxjs';\nimport { arraySize, isNil, remove, toBoolean, toNumber } from '../../../shared/functions';\nimport { filter, map, tap } from 'rxjs/operators';\nimport { PopoverController } from '@ionic/angular';\nimport { JobProgressionList, JobProgressionListOptions } from './job-progression.list';\nimport { IUserEventAction } from '../../user-event/user-event.model';\nimport { ProgressSpinnerMode } from '@angular/material/progress-spinner';\nimport { RxState } from '@rx-angular/state';\nimport { ObjectMap } from '../../../shared/types';\n\nexport interface JobProgressionOptions {\n  autoHide: boolean;\n  autoHideDelay: number;\n  autoRemove: boolean;\n  autoRemoveDelay: number;\n}\n\nexport interface JobProgressionIconState {\n  visible: boolean;\n  mode: ProgressSpinnerMode;\n  value: number;\n  jobProgressions: BehaviorSubject<JobProgression>[];\n  jobCount: number;\n}\n\n@Component({\n  selector: 'app-job-progression-icon',\n  templateUrl: './job-progression.icon.html',\n  styleUrls: ['./job-progression.icon.scss'],\n  // providers: [RxState],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class JobProgressionIcon extends RxState<JobProgressionIconState> implements OnInit, OnDestroy {\n  @Input() debug = false;\n  @Input() titleI18n = 'SOCIAL.JOB.PROGRESSION.TITLE';\n  @Input() options: JobProgressionOptions;\n  @Input() autoHide: boolean;\n  @Input() headerActions: IUserEventAction[];\n  @Output() jobFinished = new EventEmitter<number>();\n\n  disabled = true;\n  color: ThemePalette = 'accent';\n  jobProgressions$ = this.select('jobProgressions');\n  jobCount$ = this.select('jobCount');\n  visible$ = this.select('visible');\n  mode$ = this.select('mode');\n  value$ = this.select('value');\n\n  protected autoHideDelay: number;\n  protected autoRemove: boolean;\n  protected autoRemoveDelay: number;\n\n  private _listPopover: HTMLIonPopoverElement;\n  private _subscriptions = new Subscription();\n  private _subscriptionsById: ObjectMap<Subscription> = {};\n  private _logPrefix = '[job-progression] ';\n\n  constructor(\n    @Optional() @Inject(APP_JOB_PROGRESSION_SERVICE) protected jobProgressionService: IJobProgressionService,\n    protected popoverController: PopoverController,\n    protected cd: ChangeDetectorRef\n  ) {\n    super();\n  }\n\n  get jobProgressions(): BehaviorSubject<JobProgression>[] {\n    return this.get('jobProgressions');\n  }\n\n  ngOnInit() {\n    if (isNil(this.jobProgressionService)) {\n      console.warn(`${this._logPrefix}No service injected`);\n    }\n    // parse options\n    this.autoHide = toBoolean(this.autoHide, this.options?.autoHide || false);\n    this.set({ visible: !this.autoHide, mode: 'determinate', value: 0 });\n    this.autoHideDelay = toNumber(this.options?.autoHideDelay, 1000);\n    this.autoRemove = toBoolean(this.options?.autoRemove, true);\n    this.autoRemoveDelay = toNumber(this.options?.autoRemoveDelay, 1000);\n\n    if (this.jobProgressionService) {\n      this.connect('jobProgressions', this.jobProgressionService.watchAll(), (state, items) => {\n        const existingJobIds = state.jobProgressions?.map((job) => job.value.id) || [];\n        const result = (items || []).map((item) => {\n          remove(existingJobIds, (id) => id === item.id);\n          // Add job to listen\n          return this.startListenJob(item.id, item);\n        });\n        // Remove old jobs\n        if (existingJobIds.length > 0) {\n          existingJobIds.forEach((id) => this.stopListenJob(id, { emitEvent: false }));\n        }\n        return result;\n      });\n    }\n\n    this.connect('jobCount', this.jobProgressions$.pipe(map((jobs) => jobs?.length || 0)));\n\n    this.connect(\n      'visible',\n      this.jobCount$.pipe(\n        map((jobCount) => jobCount > 0),\n        switchMap((hasJob) =>\n          hasJob\n            ? of(true)\n            : of(false).pipe(\n                filter(() => this.autoHide),\n                delay(this.autoHideDelay),\n                tap(() => {\n                  if (this._listPopover) this._listPopover.dismiss();\n                })\n              )\n        )\n      )\n    );\n  }\n\n  protected startListenJob(id: number, job?: JobProgression) {\n    if (isNil(this.jobProgressionService)) {\n      console.warn(`${this._logPrefix}No service injected. Can't add a job`);\n      return;\n    }\n    if (isNil(id)) {\n      console.error(`${this._logPrefix}Missing required argument 'id'. Cannot listen changes !`);\n      return;\n    }\n    let result = this.getProgression(id);\n    if (result) {\n      //console.warn(`${this._logPrefix}Job (id=${id}) already present`);\n      return result;\n    }\n    if (this.debug) {\n      console.debug(`${this._logPrefix}Add job id=${id}`);\n    }\n    // Adding empty job progression\n    result = new BehaviorSubject(job || new JobProgression(id));\n\n    this.disabled = false;\n\n    const sub = this.jobProgressionService\n      .listenChanges(id)\n      .pipe(\n        filter((progression) => {\n          if (id !== progression.id) {\n            console.error(`${this._logPrefix}Job progression (id=${progression.id}) doesn't match expected job (id=${id})`);\n            return false;\n          }\n          return true;\n        }),\n        map((progression) => {\n          // update current\n          result.next(progression);\n          if (this.debug) {\n            console.debug(`${this._logPrefix}Progression updated id=${id}`, progression);\n          }\n          return progression;\n        })\n      )\n      .subscribe((progression) => {\n        // update value\n        this.updateValue();\n\n        // job finished\n        if (progression.total > 0 && progression.current === progression.total) {\n          if (this.debug) {\n            console.debug(`${this._logPrefix}Finished job id=${progression.id}`);\n          }\n          // emit event\n          this.jobFinished.emit(progression.id);\n          if (this.autoRemove) {\n            setTimeout(() => {\n              this.stopListenJob(progression.id);\n            }, this.autoRemoveDelay);\n          }\n        }\n      });\n\n    this._subscriptionsById[id] = sub;\n    this._subscriptions.add(sub);\n\n    return result;\n  }\n\n  protected stopListenJob(id: number, opts?: { emitEvent?: boolean }) {\n    if (this.debug) {\n      console.debug(`${this._logPrefix}Remove job id=${id}`);\n    }\n    const sub = this._subscriptionsById[id];\n    if (sub) {\n      this._subscriptions.remove(sub);\n      sub.unsubscribe();\n    }\n    // Remove job from service\n    this.jobProgressionService.removeJob(id);\n    if (!opts?.emitEvent !== false) {\n      this.updateValue();\n    }\n  }\n\n  protected getProgression(id: number): BehaviorSubject<JobProgression> | undefined {\n    return this.jobProgressions?.find((progression) => progression.value.id === id);\n  }\n\n  protected updateValue() {\n    if (this.debug) {\n      console.debug(`${this._logPrefix}Updating value`);\n    }\n    let value = 0;\n    const nbProgression = arraySize(this.jobProgressions);\n    let allIndeterminate = nbProgression > 0;\n\n    if (nbProgression) {\n      this.jobProgressions\n        .map((subject) => subject.value)\n        .forEach((progression) => {\n          const indeterminate = progression.total === 0;\n          allIndeterminate = allIndeterminate && indeterminate;\n          if (!indeterminate) {\n            value = value + (progression.current * 100) / progression.total;\n          }\n        });\n    }\n\n    this.set({ mode: allIndeterminate ? 'indeterminate' : 'determinate', value: nbProgression > 0 ? value / nbProgression : 0 });\n    if (this.debug) {\n      console.debug(`${this._logPrefix}Setting value=${this.get('value')}, mode=${this.get('mode')}`);\n    }\n\n    this.markForCheck();\n  }\n\n  async showList(event: Event) {\n    this._listPopover = await this.popoverController.create({\n      component: JobProgressionList,\n      componentProps: <JobProgressionListOptions>{\n        titleI18n: this.titleI18n,\n        jobProgressions: this.jobProgressions$,\n        headerActions: this.headerActions,\n      },\n      backdropDismiss: true,\n      keyboardClose: true,\n      event,\n      translucent: true,\n      cssClass: 'popover-large',\n    });\n    await this._listPopover.present();\n    await this._listPopover.onDidDismiss();\n    this._listPopover = undefined;\n  }\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n\n  ngOnDestroy(): void {\n    if (this.debug) {\n      console.debug(`${this._logPrefix}Destroying`);\n    }\n    this._subscriptions.unsubscribe();\n  }\n}\n","<button\n  #button\n  mat-icon-button\n  [title]=\"titleI18n | translate\"\n  [disabled]=\"disabled\"\n  *rxIf=\"visible$\"\n  (click)=\"showList($event)\"\n>\n  <mat-icon\n    *rxLet=\"jobCount$; let jobCount\"\n    [matBadge]=\"jobCount\"\n    [matBadgeHidden]=\"!jobCount\"\n    matBadgeColor=\"accent\"\n    matBadgeSize=\"small\"\n    matBadgePosition=\"above after\"\n    aria-hidden=\"false\"\n  >\n    {{ disabled || jobCount ? 'schedule' : 'task_alt' }}\n  </mat-icon>\n  <mat-spinner\n    #spinner\n    *rxIf=\"jobCount$\"\n    class=\"floating-spinner\"\n    [color]=\"color\"\n    [mode]=\"mode$ | push\"\n    [value]=\"value$ | push\"\n    diameter=\"30\"\n    strokeWidth=\"3\"\n  ></mat-spinner>\n</button>\n"]}

package/esm2022/src/app/social/job/progression/job-progression.list.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "./job-progression.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@rx-angular/template/push";
+import * as i6 from "../../../shared/pipes/arrays.pipe";
+export class JobProgressionList {
+    popoverController;
+    titleI18n;
+    headerActions;
+    jobProgressions;
+    constructor(popoverController) {
+        this.popoverController = popoverController;
+    }
+    async executeAction(event, action) {
+        if (event?.defaultPrevented)
+            return; // Skip if prevented
+        // Disable default action (.e.g avoid to call click() function)
+        if (event)
+            event.preventDefault();
+        // Execute then close popover
+        this.popoverController.dismiss();
+        try {
+            const res = action.executeAction(undefined);
+            if (res instanceof Promise)
+                await res;
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionList, deps: [{ token: i1.PopoverController }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: JobProgressionList, selector: "app-job-progression-list", inputs: { titleI18n: "titleI18n", headerActions: "headerActions", jobProgressions: "jobProgressions" }, ngImport: i0, template: "<ion-list class=\"ion-list-popover\">\n  <ion-row class=\"ion-list-header column\">\n    <ion-col>\n      <ion-label>{{ titleI18n | translate }}</ion-label>\n    </ion-col>\n    <ion-col size=\"auto\" class=\"header-action\">\n      @for (action of headerActions; track $index) {\n        <ion-text>\n          <a (click)=\"executeAction($event, action)\" [title]=\"action.title || action.name | translate\">\n            {{ action.name | translate }}\n          </a>\n        </ion-text>\n      }\n    </ion-col>\n  </ion-row>\n\n  @if (jobProgressions | async | isEmptyArray) {\n    <ion-item>\n      {{ 'SOCIAL.JOB.PROGRESSION.EMPTY' | translate }}\n    </ion-item>\n  }\n  @for (jobProgression$ of jobProgressions | push; track $index) {\n    <app-job-progression-component [jobProgression$]=\"jobProgression$\"></app-job-progression-component>\n  }\n</ion-list>\n", styles: [":host(.popover-viewport){overflow-y:auto;-webkit-user-select:none;user-select:none}.header-action{text-align:end;margin-right:8px}.header-action a{cursor:pointer;color:var(--ion-color-contrast)}.header-action a:hover{text-decoration:underline}\n"], dependencies: [{ kind: "component", type: i1.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: i1.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i1.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i1.IonList, selector: "ion-list", inputs: ["inset", "lines", "mode"] }, { kind: "component", type: i1.IonRow, selector: "ion-row" }, { kind: "component", type: i1.IonText, selector: "ion-text", inputs: ["color", "mode"] }, { kind: "component", type: i2.JobProgressionComponent, selector: "app-job-progression-component", inputs: ["showName", "jobProgression$"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "pipe", type: i5.RxPush, name: "push" }, { kind: "pipe", type: i6.EmptyArrayPipe, name: "isEmptyArray" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JobProgressionList, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-job-progression-list', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ion-list class=\"ion-list-popover\">\n  <ion-row class=\"ion-list-header column\">\n    <ion-col>\n      <ion-label>{{ titleI18n | translate }}</ion-label>\n    </ion-col>\n    <ion-col size=\"auto\" class=\"header-action\">\n      @for (action of headerActions; track $index) {\n        <ion-text>\n          <a (click)=\"executeAction($event, action)\" [title]=\"action.title || action.name | translate\">\n            {{ action.name | translate }}\n          </a>\n        </ion-text>\n      }\n    </ion-col>\n  </ion-row>\n\n  @if (jobProgressions | async | isEmptyArray) {\n    <ion-item>\n      {{ 'SOCIAL.JOB.PROGRESSION.EMPTY' | translate }}\n    </ion-item>\n  }\n  @for (jobProgression$ of jobProgressions | push; track $index) {\n    <app-job-progression-component [jobProgression$]=\"jobProgression$\"></app-job-progression-component>\n  }\n</ion-list>\n", styles: [":host(.popover-viewport){overflow-y:auto;-webkit-user-select:none;user-select:none}.header-action{text-align:end;margin-right:8px}.header-action a{cursor:pointer;color:var(--ion-color-contrast)}.header-action a:hover{text-decoration:underline}\n"] }]
+        }], ctorParameters: () => [{ type: i1.PopoverController }], propDecorators: { titleI18n: [{
+                type: Input
+            }], headerActions: [{
+                type: Input
+            }], jobProgressions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/social/job/progression/job-progression.model.mjs

@@ -0,0 +1,29 @@
+var JobProgression_1;
+import { __decorate } from "tslib";
+import { EntityClass } from '../../../core/services/model/entity.decorators';
+import { Entity } from '../../../core/services/model/entity.model';
+// @dynamic
+let JobProgression = class JobProgression extends Entity {
+    static { JobProgression_1 = this; }
+    static fromObject;
+    name;
+    message;
+    current;
+    total;
+    constructor(id) {
+        super(JobProgression_1.TYPENAME);
+        this.id = id;
+    }
+    fromObject(source) {
+        super.fromObject(source);
+        this.name = source.name;
+        this.message = source.message;
+        this.current = source.current;
+        this.total = source.total;
+    }
+};
+JobProgression = JobProgression_1 = __decorate([
+    EntityClass({ typename: 'JobProgressionVO' })
+], JobProgression);
+export { JobProgression };
+//# sourceMappingURL=data:application/json;base64,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