@solidev/data 0.0.9 → 0.1.0

package/esm2022/lib/modellist/model-list-paginator/model-list-paginator/model-list-paginator.component.mjs

@@ -0,0 +1,71 @@
+import { Component, Input } from '@angular/core';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { debounceTime, Subject, takeUntil } from 'rxjs';
+import { NgbPaginationModule } from '@ng-bootstrap/ng-bootstrap';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@ng-bootstrap/ng-bootstrap";
+class ModelListPaginatorComponent {
+    constructor() {
+        this.maxPages = 200;
+        this.hide = false;
+        this.perPageControl = new FormControl(10);
+        this.showDirectAccess = false;
+        this.directAccess = new FormControl(0);
+        this.curPage = 1;
+        this._unsubscribe = new Subject();
+    }
+    onPageChange(page) {
+        if (!page) {
+            return;
+        }
+        this.list.paginator.setPage(page);
+    }
+    ngOnDestroy() {
+        this._unsubscribe.next();
+        this._unsubscribe.complete();
+    }
+    ngOnChanges() {
+        if (this.list) {
+            this.perPageControl.setValue(this.list.paginator.getPageSize(), {
+                emitEvent: false,
+            });
+            this.list.meta.pipe(takeUntil(this._unsubscribe)).subscribe((meta) => {
+                if (meta.nav) {
+                    this.list.paginator.updatePage(meta.nav.page || 1);
+                    this.curPage = meta.nav.page || 1;
+                    this.curCount = meta.nav.count;
+                    this.list.paginator.updatePageSize(meta.nav.size);
+                    this.pageSize = this.list.paginator.getPageSize();
+                    this.perPageControl.setValue(this.pageSize, { emitEvent: false });
+                }
+            });
+            this.perPageControl.valueChanges
+                .pipe(takeUntil(this._unsubscribe))
+                .subscribe((count) => {
+                this.list.paginator.setPageSize(count);
+            });
+            this.directAccess.valueChanges
+                .pipe(takeUntil(this._unsubscribe), debounceTime(400))
+                .subscribe((count) => {
+                this.list.paginator.setPage(+count);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListPaginatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListPaginatorComponent, isStandalone: true, selector: "data-model-list-paginator", inputs: { list: "list", maxPages: "maxPages", hide: "hide" }, usesOnChanges: true, ngImport: i0, template: "\n<div class=\"row\" *ngIf=\"!hide\">\n  <div class=\"col-sm-4\">\n    <select class=\"form-select perpage\" [formControl]=\"perPageControl\">\n      <option value=\"10\" *ngIf=\"maxPages&gt;=10\">10 / page</option>\n      <option value=\"20\" *ngIf=\"maxPages&gt;=20\">20 / page</option>\n      <option value=\"50\" *ngIf=\"maxPages&gt;=50\">50 / page</option>\n      <option value=\"100\" *ngIf=\"maxPages&gt;=100\">100 / page</option>\n      <option value=\"200\" *ngIf=\"maxPages&gt;=200\">200 / page</option>\n      <option value=\"500\" *ngIf=\"maxPages&gt;=500\">500 / page</option>\n      <option value=\"1000\" *ngIf=\"maxPages&gt;=1000\">1000 / page</option>\n      <option value=\"2000\" *ngIf=\"maxPages&gt;=2000\">2000 / page</option>\n      <option value=\"5000\" *ngIf=\"maxPages&gt;=5000\">5000 / page</option>\n      <option value=\"10000\" *ngIf=\"maxPages&gt;=10000\">10000 / page</option>\n    </select>\n  </div>\n  <div class=\"col-sm-5 pagination\" *ngIf=\"list\">\n    <div class=\"text-xs-center\">\n      <ngb-pagination [pageSize]=\"pageSize\" [collectionSize]=\"curCount\" [page]=\"curPage\" (pageChange)=\"onPageChange($event)\" [maxSize]=\"5\" [rotate]=\"true\"></ngb-pagination>\n    </div>\n  </div>\n  <div class=\"col-sm-3 results\">\n    <div>{{curCount}} r\u00E9sultats -<span (click)=\"showDirectAccess=!showDirectAccess\" role=\"button\">acces direct</span></div>\n    <div *ngIf=\"showDirectAccess\">\n      <input class=\"form-control\" [formControl]=\"directAccess\" type=\"number\" placeholder=\"Aller \u00E0 la page\">\n    </div>\n  </div>\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: NgbPaginationModule }, { kind: "component", type: i3.NgbPagination, selector: "ngb-pagination", inputs: ["disabled", "boundaryLinks", "directionLinks", "ellipses", "rotate", "collectionSize", "maxSize", "page", "pageSize", "size"], outputs: ["pageChange"] }] }); }
+}
+export { ModelListPaginatorComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListPaginatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-paginator', standalone: true, imports: [CommonModule, ReactiveFormsModule, NgbPaginationModule], template: "\n<div class=\"row\" *ngIf=\"!hide\">\n  <div class=\"col-sm-4\">\n    <select class=\"form-select perpage\" [formControl]=\"perPageControl\">\n      <option value=\"10\" *ngIf=\"maxPages&gt;=10\">10 / page</option>\n      <option value=\"20\" *ngIf=\"maxPages&gt;=20\">20 / page</option>\n      <option value=\"50\" *ngIf=\"maxPages&gt;=50\">50 / page</option>\n      <option value=\"100\" *ngIf=\"maxPages&gt;=100\">100 / page</option>\n      <option value=\"200\" *ngIf=\"maxPages&gt;=200\">200 / page</option>\n      <option value=\"500\" *ngIf=\"maxPages&gt;=500\">500 / page</option>\n      <option value=\"1000\" *ngIf=\"maxPages&gt;=1000\">1000 / page</option>\n      <option value=\"2000\" *ngIf=\"maxPages&gt;=2000\">2000 / page</option>\n      <option value=\"5000\" *ngIf=\"maxPages&gt;=5000\">5000 / page</option>\n      <option value=\"10000\" *ngIf=\"maxPages&gt;=10000\">10000 / page</option>\n    </select>\n  </div>\n  <div class=\"col-sm-5 pagination\" *ngIf=\"list\">\n    <div class=\"text-xs-center\">\n      <ngb-pagination [pageSize]=\"pageSize\" [collectionSize]=\"curCount\" [page]=\"curPage\" (pageChange)=\"onPageChange($event)\" [maxSize]=\"5\" [rotate]=\"true\"></ngb-pagination>\n    </div>\n  </div>\n  <div class=\"col-sm-3 results\">\n    <div>{{curCount}} r\u00E9sultats -<span (click)=\"showDirectAccess=!showDirectAccess\" role=\"button\">acces direct</span></div>\n    <div *ngIf=\"showDirectAccess\">\n      <input class=\"form-control\" [formControl]=\"directAccess\" type=\"number\" placeholder=\"Aller \u00E0 la page\">\n    </div>\n  </div>\n</div>" }]
+        }], propDecorators: { list: [{
+                type: Input
+            }], maxPages: [{
+                type: Input
+            }], hide: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list-paginator.component.js","sourceRoot":"","sources":["../../../../../../../projects/data/src/lib/modellist/model-list-paginator/model-list-paginator/model-list-paginator.component.ts","../../../../../../../projects/data/src/lib/modellist/model-list-paginator/model-list-paginator/model-list-paginator.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, OnDestroy } from '@angular/core';\nimport { ModelList } from '../../model-list.service';\nimport { FormControl, ReactiveFormsModule } from '@angular/forms';\nimport { debounceTime, Subject, takeUntil } from 'rxjs';\nimport { NgbPaginationModule } from '@ng-bootstrap/ng-bootstrap';\nimport { CommonModule } from '@angular/common';\nimport { DataModel } from '../../../data/data-model';\n\n@Component({\n  selector: 'data-model-list-paginator',\n  templateUrl: './model-list-paginator.component.html',\n  styleUrls: ['./model-list-paginator.component.sass'],\n  standalone: true,\n  imports: [CommonModule, ReactiveFormsModule, NgbPaginationModule],\n})\nexport class ModelListPaginatorComponent<T extends DataModel>\n  implements OnDestroy, OnChanges\n{\n  @Input() public list!: ModelList<T>;\n  @Input() public maxPages = 200;\n  @Input() public hide = false;\n\n  public perPageControl: FormControl = new FormControl<number>(10);\n  public showDirectAccess = false;\n  public directAccess: FormControl = new FormControl<number>(0);\n  public curPage = 1;\n  public curCount!: number;\n  public pageSize!: number;\n  public _unsubscribe = new Subject<void>();\n\n  public onPageChange(page: number): void {\n    if (!page) {\n      return;\n    }\n    this.list.paginator.setPage(page);\n  }\n\n  public ngOnDestroy(): void {\n    this._unsubscribe.next();\n    this._unsubscribe.complete();\n  }\n\n  public ngOnChanges(): void {\n    if (this.list) {\n      this.perPageControl.setValue(this.list.paginator.getPageSize(), {\n        emitEvent: false,\n      });\n      this.list.meta.pipe(takeUntil(this._unsubscribe)).subscribe((meta) => {\n        if (meta.nav) {\n          this.list.paginator.updatePage(meta.nav.page || 1);\n          this.curPage = meta.nav.page || 1;\n          this.curCount = meta.nav.count;\n          this.list.paginator.updatePageSize(meta.nav.size);\n          this.pageSize = this.list.paginator.getPageSize();\n          this.perPageControl.setValue(this.pageSize, { emitEvent: false });\n        }\n      });\n\n      this.perPageControl.valueChanges\n        .pipe(takeUntil(this._unsubscribe))\n        .subscribe((count) => {\n          this.list.paginator.setPageSize(count);\n        });\n\n      this.directAccess.valueChanges\n        .pipe(takeUntil(this._unsubscribe), debounceTime(400))\n        .subscribe((count) => {\n          this.list.paginator.setPage(+count);\n        });\n    }\n  }\n}\n","\n<div class=\"row\" *ngIf=\"!hide\">\n  <div class=\"col-sm-4\">\n    <select class=\"form-select perpage\" [formControl]=\"perPageControl\">\n      <option value=\"10\" *ngIf=\"maxPages&gt;=10\">10 / page</option>\n      <option value=\"20\" *ngIf=\"maxPages&gt;=20\">20 / page</option>\n      <option value=\"50\" *ngIf=\"maxPages&gt;=50\">50 / page</option>\n      <option value=\"100\" *ngIf=\"maxPages&gt;=100\">100 / page</option>\n      <option value=\"200\" *ngIf=\"maxPages&gt;=200\">200 / page</option>\n      <option value=\"500\" *ngIf=\"maxPages&gt;=500\">500 / page</option>\n      <option value=\"1000\" *ngIf=\"maxPages&gt;=1000\">1000 / page</option>\n      <option value=\"2000\" *ngIf=\"maxPages&gt;=2000\">2000 / page</option>\n      <option value=\"5000\" *ngIf=\"maxPages&gt;=5000\">5000 / page</option>\n      <option value=\"10000\" *ngIf=\"maxPages&gt;=10000\">10000 / page</option>\n    </select>\n  </div>\n  <div class=\"col-sm-5 pagination\" *ngIf=\"list\">\n    <div class=\"text-xs-center\">\n      <ngb-pagination [pageSize]=\"pageSize\" [collectionSize]=\"curCount\" [page]=\"curPage\" (pageChange)=\"onPageChange($event)\" [maxSize]=\"5\" [rotate]=\"true\"></ngb-pagination>\n    </div>\n  </div>\n  <div class=\"col-sm-3 results\">\n    <div>{{curCount}} résultats -<span (click)=\"showDirectAccess=!showDirectAccess\" role=\"button\">acces direct</span></div>\n    <div *ngIf=\"showDirectAccess\">\n      <input class=\"form-control\" [formControl]=\"directAccess\" type=\"number\" placeholder=\"Aller à la page\">\n    </div>\n  </div>\n</div>"]}

package/esm2022/lib/modellist/model-list-sorter/model-list-sorter/model-list-sorter.component.mjs

@@ -0,0 +1,50 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+class ModelListSorterComponent {
+    constructor() { }
+    isUp() {
+        const f = this.list.sorter.get(this.field);
+        if (f) {
+            return f.direction === 'asc';
+        }
+        return false;
+    }
+    isDown() {
+        const f = this.list.sorter.get(this.field);
+        if (f) {
+            return f.direction === 'desc';
+        }
+        return false;
+    }
+    setUp() {
+        this.list.sorter.set(this.field, 'asc');
+    }
+    setDown() {
+        this.list.sorter.set(this.field, 'desc');
+    }
+    getCount() {
+        return this.list.sorter.get(this.field)
+            ? this.list.sorter.getAll().length
+            : 0;
+    }
+    getOrder() {
+        return this.list.sorter.getOrder(this.field);
+    }
+    cancel() {
+        this.list.sorter.unset(this.field);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSorterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListSorterComponent, isStandalone: true, selector: "data-model-list-sorter", inputs: { list: "list", field: "field" }, ngImport: i0, template: "<span class=\"dirs\"><span *ngIf=\"getOrder()&gt;=0 || getCount()&gt;1\" (click)=\"cancel()\" role=\"button\"><span class=\"count\" *ngIf=\"getCount()&gt;1\"> {{getOrder()}}</span><span class=\"bi bi-x\"></span></span><span class=\"bi bi-sort-down-alt\" (click)=\"setUp()\" [class.active]=\"isUp()\" role=\"button\"></span><span class=\"bi bi-sort-down\" (click)=\"setDown()\" [class.active]=\"isDown()\" role=\"button\"></span>&nbsp;</span>\n<ng-content></ng-content>", styles: [".dirs{color:#d3d3d3}.dirs .count{font-size:.7rem;margin-right:-.1rem;vertical-align:super}.active{color:#000}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+export { ModelListSorterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSorterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-sorter', standalone: true, imports: [CommonModule], template: "<span class=\"dirs\"><span *ngIf=\"getOrder()&gt;=0 || getCount()&gt;1\" (click)=\"cancel()\" role=\"button\"><span class=\"count\" *ngIf=\"getCount()&gt;1\"> {{getOrder()}}</span><span class=\"bi bi-x\"></span></span><span class=\"bi bi-sort-down-alt\" (click)=\"setUp()\" [class.active]=\"isUp()\" role=\"button\"></span><span class=\"bi bi-sort-down\" (click)=\"setDown()\" [class.active]=\"isDown()\" role=\"button\"></span>&nbsp;</span>\n<ng-content></ng-content>", styles: [".dirs{color:#d3d3d3}.dirs .count{font-size:.7rem;margin-right:-.1rem;vertical-align:super}.active{color:#000}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modellist/model-list.service.mjs

@@ -0,0 +1,158 @@
+import { Inject, Injectable } from '@angular/core';
+import { combineLatest, NEVER, of, ReplaySubject, share, Subject, takeUntil, } from 'rxjs';
+import { switchMap, tap, throttleTime } from 'rxjs/operators';
+import { ModelListFields } from './model-list-fields/model-list-fields';
+import { ModelListPaginator } from './model-list-paginator/model-list-paginator';
+import { ModelListSorter } from './model-list-sorter/model-list-sorter';
+import { ModelListFilters } from './model-list-filters/model-list-filters';
+import { DATA_AUTH_SERVICE } from '../auth/auth-interceptor.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth/auth.service";
+export class ModelList {
+    constructor(name) {
+        this.messages$ = new ReplaySubject(1);
+        this.started = false;
+        this.name = name;
+    }
+    get results() {
+        if (!this._results) {
+            this._results = this.queryset.results.pipe(
+            // tap(() => console.log('@solidev/data: modellist result')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._results;
+    }
+    get meta() {
+        if (!this._meta) {
+            this._meta = this.queryset.meta.pipe(
+            // tap(() => console.log('@solidev/data: modellist meta')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._meta;
+    }
+    get loading() {
+        if (!this._loading) {
+            this._loading = this.queryset.loading.pipe(
+            // tap(() => console.log('@solidev/data: modellist loading')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._loading;
+    }
+    get full() {
+        if (!this._full) {
+            this._full = this.queryset.full.pipe(
+            // tap(() => console.log('@solidev/data: modellist full')),
+            share(), takeUntil(this.unsubscribe || NEVER));
+        }
+        return this._full;
+    }
+    start(params) {
+        let filter$;
+        let reloadFired = false;
+        if (params.filter && !params.filter.subscribe) {
+            filter$ = of(params.filter);
+        }
+        else if (params.filter && params.filter.subscribe) {
+            filter$ = params.filter;
+        }
+        else {
+            filter$ = of({});
+        }
+        combineLatest([
+            this.reload.pipe(tap((v) => (reloadFired = !!v))),
+            this.filters.output,
+            filter$,
+            this.paginator.output,
+            this.sorter.output,
+            this.fields.output,
+        ])
+            .pipe(throttleTime(200), switchMap(([reload, filter, manualFilter, paginator, sorter, fields]) => {
+            this.queryset
+                .filter(filter)
+                .filter(manualFilter || {}, true)
+                .paginateBy(paginator.page_size)
+                .setPage(paginator.page)
+                .sort(...sorter)
+                .setFields(fields);
+            const dbSync = reloadFired;
+            reloadFired = false;
+            return this.queryset.get(true, dbSync);
+        }), takeUntil(this.unsubscribe || NEVER))
+            .subscribe({
+            next: (results) => {
+                // console.log('@solidev/data: modellist:get results', this.name);
+            },
+            error: (error) => {
+                console.error('@solidev/data: error while getting model list results : ', error);
+            },
+            complete: () => {
+                // console.log('@solidev/data: modellist:completed', this.name);
+                this.started = false;
+            },
+        });
+        this.reload.next();
+        this.started = true;
+    }
+}
+class ModelListService {
+    constructor(_auth) {
+        this._auth = _auth;
+        this._instances = new Map();
+        this._auth.logout$.subscribe(() => this.reset());
+    }
+    reset() {
+        for (const i of this._instances.values()) {
+            if (i.unsubscribe) {
+                console.log('Clearing ', i);
+                i.unsubscribe.next();
+            }
+        }
+        this._instances.clear();
+    }
+    get(name, collection, defaults) {
+        let ml;
+        if (!name || !this._instances.has(name) || !defaults.keep) {
+            ml = new ModelList(name);
+            ml.queryset = collection.queryset();
+            ml.fields = new ModelListFields(collection, defaults.fields);
+            ml.sorter = new ModelListSorter(defaults.sorter || []);
+            ml.paginator = new ModelListPaginator(defaults.paginator);
+            ml.filters = new ModelListFilters(defaults.filters);
+            if (defaults.keep) {
+                this._instances.set(name, ml);
+            }
+        }
+        else {
+            ml = this._instances.get(name);
+        }
+        if (!ml.started) {
+            if (defaults.reload) {
+                ml.reload = defaults.reload;
+            }
+            else {
+                ml.reload = new Subject();
+            }
+            if (defaults.unsubscribe) {
+                ml.unsubscribe = defaults.unsubscribe;
+            }
+            else {
+                ml.unsubscribe = new Subject();
+            }
+            ml.start(defaults);
+        }
+        return ml;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListService, deps: [{ token: DATA_AUTH_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListService, providedIn: 'root' }); }
+}
+export { ModelListService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthServiceBase, decorators: [{
+                    type: Inject,
+                    args: [DATA_AUTH_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list.service.js","sourceRoot":"","sources":["../../../../../projects/data/src/lib/modellist/model-list.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,aAAa,EACb,KAAK,EAEL,EAAE,EACF,aAAa,EACb,KAAK,EACL,OAAO,EACP,SAAS,GACV,MAAM,MAAM,CAAC;AAQd,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAK3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;;;AAyDrE,MAAM,OAAO,SAAS;IAYpB,YAAY,IAAY;QAHjB,cAAS,GAAG,IAAI,aAAa,CAAoB,CAAC,CAAC,CAAC;QACpD,YAAO,GAAG,KAAK,CAAC;QAGrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAID,IAAW,OAAO;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI;YACxC,6DAA6D;YAC7D,KAAK,EAAE,EACP,SAAS,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,CACrC,CAAC;SACH;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAID,IAAW,IAAI;QACb,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI;YAClC,2DAA2D;YAC3D,KAAK,EAAE,EACP,SAAS,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,CACrC,CAAC;SACH;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAID,IAAW,OAAO;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI;YACxC,8DAA8D;YAC9D,KAAK,EAAE,EACP,SAAS,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,CACrC,CAAC;SACH;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAID,IAAW,IAAI;QACb,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI;YAClC,2DAA2D;YAC3D,KAAK,EAAE,EACP,SAAS,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,CACrC,CAAC;SACH;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAEM,KAAK,CAAC,MAAuB;QAClC,IAAI,OAAmC,CAAC;QACxC,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE;YAC7C,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,MAAwB,CAAC,CAAC;SAC/C;aAAM,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE;YACnD,OAAO,GAAG,MAAM,CAAC,MAAoC,CAAC;SACvD;aAAM;YACL,OAAO,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;SAClB;QACD,aAAa,CAAC;YACZ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,IAAI,CAAC,OAAO,CAAC,MAAM;YACnB,OAAO;YACP,IAAI,CAAC,SAAS,CAAC,MAAM;YACrB,IAAI,CAAC,MAAM,CAAC,MAAM;YAClB,IAAI,CAAC,MAAM,CAAC,MAAM;SACnB,CAAC;aACC,IAAI,CACH,YAAY,CAAC,GAAG,CAAC,EACjB,SAAS,CACP,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE;YAC5D,IAAI,CAAC,QAAQ;iBACV,MAAM,CAAC,MAAM,CAAC;iBACd,MAAM,CAAC,YAAY,IAAI,EAAE,EAAE,IAAI,CAAC;iBAChC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC;iBAC/B,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;iBACvB,IAAI,CAAC,GAAG,MAAM,CAAC;iBACf,SAAS,CAAC,MAAM,CAAC,CAAC;YACrB,MAAM,MAAM,GAAG,WAAW,CAAC;YAC3B,WAAW,GAAG,KAAK,CAAC;YACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzC,CAAC,CACF,EACD,SAAS,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,CACrC;aACA,SAAS,CAAC;YACT,IAAI,EAAE,CAAC,OAAY,EAAQ,EAAE;gBAC3B,kEAAkE;YACpE,CAAC;YACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;gBACf,OAAO,CAAC,KAAK,CACX,0DAA0D,EAC1D,KAAK,CACN,CAAC;YACJ,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE;gBACb,gEAAgE;gBAChE,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACvB,CAAC;SACF,CAAC,CAAC;QACL,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;CACF;AAED,MAGa,gBAAgB;IAG3B,YACqC,KAAqC;QAArC,UAAK,GAAL,KAAK,CAAgC;QAHlE,eAAU,GAAgC,IAAI,GAAG,EAAE,CAAC;QAK1D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;IAEM,KAAK;QACV,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE;YACxC,IAAI,CAAC,CAAC,WAAW,EAAE;gBACjB,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;gBAC5B,CAAC,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;aACtB;SACF;QACD,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAEM,GAAG,CACR,IAAY,EACZ,UAAyB,EACzB,QAAyB;QAEzB,IAAI,EAAgB,CAAC;QAErB,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;YACzD,EAAE,GAAG,IAAI,SAAS,CAAI,IAAI,CAAC,CAAC;YAC5B,EAAE,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC;YACpC,EAAE,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC7D,EAAE,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;YACvD,EAAE,CAAC,SAAS,GAAG,IAAI,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC1D,EAAE,CAAC,OAAO,GAAG,IAAI,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACpD,IAAI,QAAQ,CAAC,IAAI,EAAE;gBACjB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;aAC/B;SACF;aAAM;YACL,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;SACjC;QACD,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE;YACf,IAAI,QAAQ,CAAC,MAAM,EAAE;gBACnB,EAAE,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;aAC7B;iBAAM;gBACL,EAAE,CAAC,MAAM,GAAG,IAAI,OAAO,EAAkB,CAAC;aAC3C;YACD,IAAI,QAAQ,CAAC,WAAW,EAAE;gBACxB,EAAE,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;aACvC;iBAAM;gBACL,EAAE,CAAC,WAAW,GAAG,IAAI,OAAO,EAAQ,CAAC;aACtC;YACD,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;SACpB;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;8GArDU,gBAAgB,kBAIjB,iBAAiB;kHAJhB,gBAAgB,cAFf,MAAM;;SAEP,gBAAgB;2FAAhB,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAKI,MAAM;2BAAC,iBAAiB","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport {\n  combineLatest,\n  NEVER,\n  Observable,\n  of,\n  ReplaySubject,\n  share,\n  Subject,\n  takeUntil,\n} from 'rxjs';\nimport { DataModel } from '../data/data-model';\nimport {\n  IQueryMeta,\n  IQueryMetaNavParams,\n  IQueryNav,\n  Queryset,\n} from '../data/data-query';\nimport { switchMap, tap, throttleTime } from 'rxjs/operators';\nimport { ModelListFields } from './model-list-fields/model-list-fields';\nimport { ModelListPaginator } from './model-list-paginator/model-list-paginator';\nimport { ModelListSorter } from './model-list-sorter/model-list-sorter';\nimport { ModelListFilters } from './model-list-filters/model-list-filters';\nimport { Collection } from '../data/data-collection';\nimport { ModelListFilter } from './model-list-filters/model-list-filter';\nimport { IFieldHeaderMessage } from './model-list-fields/model-list-field-header/messages';\nimport { AuthServiceBase } from '../auth/auth.service';\nimport { DATA_AUTH_SERVICE } from '../auth/auth-interceptor.service';\n\nexport interface CustomField {\n  name: string;\n  label: string;\n  priority?: number;\n}\n\nexport interface FilterDefaults {\n  [index: string]: string | number | undefined;\n}\n\nexport type SorterDefaults = string[];\n\n/**\n * Fields parameters.\n */\nexport interface FieldsParams {\n  /** Allowed fields, all model fields are allowed if empty */\n  allowed?: string[];\n  /** Default enabled fields */\n  defaults?: string[];\n  /** Excluded fields */\n  excluded?: string[];\n  /** Custom fields */\n  custom?: CustomField[];\n}\n\n/**\n * Filters parameters.\n */\nexport interface FiltersParams {\n  /** Allowed filter names */\n  allowed?: string[];\n  /** Default active filter names */\n  defaults?: string[];\n  /** Excluded filter names */\n  excluded?: string[];\n  /** Filters definitions */\n  filters?: ModelListFilter[];\n}\n\nexport type PaginationParams = IQueryMetaNavParams;\n\nexport type IModelListMessage = IFieldHeaderMessage;\n\nexport interface ModelListParams {\n  fields?: FieldsParams;\n  filters?: FiltersParams;\n  filter?: FilterDefaults | Observable<FilterDefaults>;\n  sorter?: SorterDefaults;\n  paginator?: IQueryNav;\n  keep?: boolean;\n  reload?: Subject<void | boolean>;\n  unsubscribe?: Subject<void>;\n}\n\nexport class ModelList<T extends DataModel> {\n  public name!: string;\n  public filters!: ModelListFilters;\n  public sorter!: ModelListSorter;\n  public paginator!: ModelListPaginator;\n  public queryset!: Queryset<T>;\n  public fields!: ModelListFields<T>;\n  public reload!: Subject<void | boolean>;\n  public unsubscribe!: Subject<void>;\n  public messages$ = new ReplaySubject<IModelListMessage>(1);\n  public started = false;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  private _results?: Observable<T[]>;\n\n  public get results(): Observable<T[]> {\n    if (!this._results) {\n      this._results = this.queryset.results.pipe(\n        // tap(() => console.log('@solidev/data: modellist result')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._results;\n  }\n\n  private _meta?: Observable<IQueryMeta>;\n\n  public get meta(): Observable<IQueryMeta> {\n    if (!this._meta) {\n      this._meta = this.queryset.meta.pipe(\n        // tap(() => console.log('@solidev/data: modellist meta')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._meta;\n  }\n\n  private _loading?: Observable<boolean>;\n\n  public get loading(): Observable<boolean> {\n    if (!this._loading) {\n      this._loading = this.queryset.loading.pipe(\n        // tap(() => console.log('@solidev/data: modellist loading')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._loading;\n  }\n\n  private _full?: Observable<[T[], boolean, IQueryMeta]>;\n\n  public get full(): Observable<[T[], boolean, IQueryMeta]> {\n    if (!this._full) {\n      this._full = this.queryset.full.pipe(\n        // tap(() => console.log('@solidev/data: modellist full')),\n        share(),\n        takeUntil(this.unsubscribe || NEVER)\n      );\n    }\n    return this._full;\n  }\n\n  public start(params: ModelListParams) {\n    let filter$: Observable<FilterDefaults>;\n    let reloadFired = false;\n    if (params.filter && !params.filter.subscribe) {\n      filter$ = of(params.filter as FilterDefaults);\n    } else if (params.filter && params.filter.subscribe) {\n      filter$ = params.filter as Observable<FilterDefaults>;\n    } else {\n      filter$ = of({});\n    }\n    combineLatest([\n      this.reload.pipe(tap((v) => (reloadFired = !!v))),\n      this.filters.output,\n      filter$,\n      this.paginator.output,\n      this.sorter.output,\n      this.fields.output,\n    ])\n      .pipe(\n        throttleTime(200),\n        switchMap(\n          ([reload, filter, manualFilter, paginator, sorter, fields]) => {\n            this.queryset\n              .filter(filter)\n              .filter(manualFilter || {}, true)\n              .paginateBy(paginator.page_size)\n              .setPage(paginator.page)\n              .sort(...sorter)\n              .setFields(fields);\n            const dbSync = reloadFired;\n            reloadFired = false;\n            return this.queryset.get(true, dbSync);\n          }\n        ),\n        takeUntil(this.unsubscribe || NEVER)\n      )\n      .subscribe({\n        next: (results: any): void => {\n          // console.log('@solidev/data: modellist:get results', this.name);\n        },\n        error: (error) => {\n          console.error(\n            '@solidev/data: error while getting model list results : ',\n            error\n          );\n        },\n        complete: () => {\n          // console.log('@solidev/data: modellist:completed', this.name);\n          this.started = false;\n        },\n      });\n    this.reload.next();\n    this.started = true;\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModelListService {\n  private _instances: Map<string, ModelList<any>> = new Map();\n\n  constructor(\n    @Inject(DATA_AUTH_SERVICE) private _auth: AuthServiceBase<any, any, any>\n  ) {\n    this._auth.logout$.subscribe(() => this.reset());\n  }\n\n  public reset() {\n    for (const i of this._instances.values()) {\n      if (i.unsubscribe) {\n        console.log('Clearing ', i);\n        i.unsubscribe.next();\n      }\n    }\n    this._instances.clear();\n  }\n\n  public get<T extends DataModel>(\n    name: string,\n    collection: Collection<T>,\n    defaults: ModelListParams\n  ) {\n    let ml: ModelList<T>;\n\n    if (!name || !this._instances.has(name) || !defaults.keep) {\n      ml = new ModelList<T>(name);\n      ml.queryset = collection.queryset();\n      ml.fields = new ModelListFields(collection, defaults.fields);\n      ml.sorter = new ModelListSorter(defaults.sorter || []);\n      ml.paginator = new ModelListPaginator(defaults.paginator);\n      ml.filters = new ModelListFilters(defaults.filters);\n      if (defaults.keep) {\n        this._instances.set(name, ml);\n      }\n    } else {\n      ml = this._instances.get(name)!;\n    }\n    if (!ml.started) {\n      if (defaults.reload) {\n        ml.reload = defaults.reload;\n      } else {\n        ml.reload = new Subject<void | boolean>();\n      }\n      if (defaults.unsubscribe) {\n        ml.unsubscribe = defaults.unsubscribe;\n      } else {\n        ml.unsubscribe = new Subject<void>();\n      }\n      ml.start(defaults);\n    }\n    return ml;\n  }\n}\n"]}

package/esm2022/lib/routing/breadcrumb/breadcrumb.component.mjs

@@ -0,0 +1,143 @@
+import { Component, Input, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { NavigationEnd, RouterModule, } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+/**
+ * Use data from route config to create a breadcrumb for current route.
+ *
+ * Route config data is :
+ * - title : route fragment title or lodash template to build title
+ *   (provided arguments for template processing : route (current segment route snapshot)
+ *   and data (input argument)
+ * - icon: icon classes. Example fa fa-home for home & font awesome
+ */
+class BreadcrumbComponent {
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+        /**
+         * Do we display icons ?
+         */
+        this.icons = true;
+        this.tree = [];
+        this._subscriptions = new Subject();
+    }
+    ngOnInit() {
+        this.getRouteTree(this.router.routerState);
+        this.router.events
+            .pipe(takeUntil(this._subscriptions), filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => {
+            this.getRouteTree(this.router.routerState);
+        });
+    }
+    ngOnDestroy() {
+        this._subscriptions.next();
+        this._subscriptions.complete();
+    }
+    ngOnChanges(changes) {
+        this.getRouteTree(this.router.routerState);
+    }
+    getRouteTree(current) {
+        const tree = [];
+        const url = [];
+        let p = current.root.snapshot;
+        while (p != null) {
+            let rdata = {
+                tree: false,
+                title: () => 'xxxx',
+                icon: '',
+                skip: true,
+            };
+            const data = p.data;
+            // Get route data
+            if (p.routeConfig && p.routeConfig.data) {
+                rdata = p.routeConfig.data;
+            }
+            if (rdata.tree) {
+                // Get icon
+                for (const u of p.url) {
+                    url.push(u.path);
+                    let rtd = {
+                        icon: this.getIcon(rdata, data),
+                        title: this.getTitle(rdata, data, u),
+                        path: url.join('/'),
+                        current: false,
+                    };
+                    if (rtd.path.length > 0 && rtd.path[0] !== '/') {
+                        rtd.path = '/' + rtd.path;
+                    }
+                    if (!rdata.skip) {
+                        tree.push(rtd);
+                    }
+                }
+            }
+            else {
+                url.push(p.url.join('/'));
+                let rtd = {
+                    icon: this.getIcon(rdata, data),
+                    title: this.getTitle(rdata, data),
+                    path: url.join('/'),
+                    current: false,
+                };
+                if (rtd.path.length > 0 && rtd.path[0] !== '/') {
+                    rtd.path = '/' + rtd.path;
+                }
+                if (!rdata.skip) {
+                    tree.push(rtd);
+                }
+            }
+            p = p.firstChild;
+        }
+        if (tree.length > 0) {
+            tree[tree.length - 1].current = true;
+        }
+        this.tree = tree;
+    }
+    getTitle(rdata, data, u) {
+        if (rdata['title']) {
+            if (typeof rdata['title'] === 'function') {
+                const tpl = rdata['title'];
+                try {
+                    if (u) {
+                        return tpl(data, u.path);
+                    }
+                    else {
+                        return tpl(data);
+                    }
+                }
+                catch (e) {
+                    console.warn('Unable to process breadcrumb function', e);
+                    if (data.title != null) {
+                        return 'xx';
+                    }
+                }
+            }
+            else {
+                return rdata['title'];
+            }
+        }
+        return 'xxx';
+    }
+    getIcon(rdata, data) {
+        if (data.icon) {
+            return data.icon;
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BreadcrumbComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: BreadcrumbComponent, isStandalone: true, selector: "data-breadcrumb", inputs: { data: "data", icons: "icons" }, usesOnChanges: true, ngImport: i0, template: "\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i1.RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }] }); }
+}
+export { BreadcrumbComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-breadcrumb', standalone: true, imports: [CommonModule, RouterModule], template: "\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>" }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; }, propDecorators: { data: [{
+                type: Input
+            }], icons: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.component.js","sourceRoot":"","sources":["../../../../../../projects/data/src/lib/routing/breadcrumb/breadcrumb.component.ts","../../../../../../projects/data/src/lib/routing/breadcrumb/breadcrumb.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport {\n  ActivatedRoute,\n  ActivatedRouteSnapshot,\n  NavigationEnd,\n  Router,\n  RouterModule,\n  RouterState,\n  UrlSegment,\n} from '@angular/router';\nimport { filter } from 'rxjs/operators';\nimport { CommonModule } from '@angular/common';\nimport { BaseRouteParams, TplFn } from '../routing';\n\nexport interface IPathTreeItem {\n  path: string;\n  title: string;\n  icon: string;\n  current: boolean;\n}\n\n/**\n * Use data from route config to create a breadcrumb for current route.\n *\n * Route config data is :\n * - title : route fragment title or lodash template to build title\n *   (provided arguments for template processing : route (current segment route snapshot)\n *   and data (input argument)\n * - icon: icon classes. Example fa fa-home for home & font awesome\n */\n@Component({\n  selector: 'data-breadcrumb',\n  templateUrl: './breadcrumb.component.html',\n  styleUrls: ['./breadcrumb.component.css'],\n  standalone: true,\n  imports: [CommonModule, RouterModule],\n})\nexport class BreadcrumbComponent implements OnChanges, OnInit, OnDestroy {\n  /**\n   * Additional data to be used in titleTemplate\n   */\n  @Input() public data: any;\n  /**\n   * Do we display icons ?\n   */\n  @Input() public icons = true;\n  public tree: IPathTreeItem[] = [];\n  private _subscriptions = new Subject<void>();\n\n  constructor(public router: Router, public route: ActivatedRoute) {}\n\n  ngOnInit(): void {\n    this.getRouteTree(this.router.routerState);\n    this.router.events\n      .pipe(\n        takeUntil(this._subscriptions),\n        filter((event) => event instanceof NavigationEnd)\n      )\n      .subscribe(() => {\n        this.getRouteTree(this.router.routerState);\n      });\n  }\n\n  public ngOnDestroy() {\n    this._subscriptions.next();\n    this._subscriptions.complete();\n  }\n\n  public ngOnChanges(changes: SimpleChanges) {\n    this.getRouteTree(this.router.routerState);\n  }\n\n  public getRouteTree(current: RouterState): void {\n    const tree: IPathTreeItem[] = [];\n    const url: string[] = [];\n    let p: ActivatedRouteSnapshot | null = current.root.snapshot;\n\n    while (p != null) {\n      let rdata: Partial<BaseRouteParams> = {\n        tree: false,\n        title: () => 'xxxx',\n        icon: '',\n        skip: true,\n      };\n      const data = p.data as BaseRouteParams;\n\n      // Get route data\n      if (p.routeConfig && p.routeConfig.data) {\n        rdata = p.routeConfig.data as BaseRouteParams;\n      }\n\n      if (rdata.tree) {\n        // Get icon\n        for (const u of p.url) {\n          url.push(u.path);\n          let rtd: IPathTreeItem = {\n            icon: this.getIcon(rdata, data),\n            title: this.getTitle(rdata, data, u),\n            path: url.join('/'),\n            current: false,\n          };\n          if (rtd.path.length > 0 && rtd.path[0] !== '/') {\n            rtd.path = '/' + rtd.path;\n          }\n          if (!rdata.skip) {\n            tree.push(rtd);\n          }\n        }\n      } else {\n        url.push(p.url.join('/'));\n        let rtd: IPathTreeItem = {\n          icon: this.getIcon(rdata, data),\n          title: this.getTitle(rdata, data),\n          path: url.join('/'),\n          current: false,\n        };\n        if (rtd.path.length > 0 && rtd.path[0] !== '/') {\n          rtd.path = '/' + rtd.path;\n        }\n        if (!rdata.skip) {\n          tree.push(rtd);\n        }\n      }\n\n      p = p.firstChild;\n    }\n    if (tree.length > 0) {\n      tree[tree.length - 1].current = true;\n    }\n    this.tree = tree;\n  }\n\n  public getTitle(\n    rdata: Partial<BaseRouteParams>,\n    data: BaseRouteParams,\n    u?: UrlSegment\n  ): string {\n    if (rdata['title']) {\n      if (typeof rdata['title'] === 'function') {\n        const tpl: TplFn<any> = rdata['title'];\n        try {\n          if (u) {\n            return tpl(data, u.path);\n          } else {\n            return tpl(data);\n          }\n        } catch (e) {\n          console.warn('Unable to process breadcrumb function', e);\n          if (data.title != null) {\n            return 'xx';\n          }\n        }\n      } else {\n        return rdata['title'];\n      }\n    }\n    return 'xxx';\n  }\n\n  public getIcon(\n    rdata: Partial<BaseRouteParams>,\n    data: BaseRouteParams\n  ): string {\n    if (data.icon) {\n      return data.icon;\n    }\n    return '';\n  }\n}\n","\n<nav aria-label=\"breadcrumb\">\n  <ol class=\"breadcrumb\">\n    <ng-container *ngFor=\"let p of tree\">\n      <li class=\"breadcrumb-item\" *ngIf=\"!p.current\"><a class=\"breadcrumb-item\" [routerLink]=\"p.path\">\n          <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-2\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n          <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container></a></li>\n      <li class=\"breadcrumb-item active\" aria-current=\"page\" *ngIf=\"p.current\">\n        <ng-container *ngIf=\"icons &amp;&amp; p.icon\"><i class=\"me-1\" [ngClass]=\"p.icon\"></i>{{p.title}}</ng-container>\n        <ng-container *ngIf=\"!(icons &amp;&amp; p.icon)\">{{p.title}}</ng-container>\n      </li>\n    </ng-container>\n  </ol>\n</nav>"]}

package/esm2022/lib/updates/update/update.component.mjs

@@ -0,0 +1,18 @@
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../update.service";
+import * as i2 from "@angular/common";
+class UpdateComponent {
+    constructor(update) {
+        this.update = update;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UpdateComponent, deps: [{ token: i1.UpdateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: UpdateComponent, isStandalone: true, selector: "data-update", ngImport: i0, template: "\n<div class=\"snack\" *ngIf=\"update.available$|async\">\n  <p>Une nouvelle version de l'application est disponible.</p>\n  <div class=\"row\">\n    <div class=\"col-sm-6\">\n      <button class=\"btn btn-primary btn-block w-100\" (click)=\"update.activate()\">L'ACTIVER MAINTENANT</button>\n    </div>\n    <div class=\"col-sm-6\">\n      <button class=\"btn btn-warning btn-block w-100\" (click)=\"update.dismiss()\">Plus tard</button>\n    </div>\n  </div>\n</div>", styles: [".snack{position:fixed;bottom:0;margin-left:auto;margin-right:auto;left:auto;right:auto;background-color:#ff7a00cc;padding:20px;z-index:2000;border-top:1px solid rgb(255,122,0);font-size:1.5rem;font-weight:700;color:#8b0000;width:100%;text-align:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] }); }
+}
+export { UpdateComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UpdateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-update', standalone: true, imports: [CommonModule], template: "\n<div class=\"snack\" *ngIf=\"update.available$|async\">\n  <p>Une nouvelle version de l'application est disponible.</p>\n  <div class=\"row\">\n    <div class=\"col-sm-6\">\n      <button class=\"btn btn-primary btn-block w-100\" (click)=\"update.activate()\">L'ACTIVER MAINTENANT</button>\n    </div>\n    <div class=\"col-sm-6\">\n      <button class=\"btn btn-warning btn-block w-100\" (click)=\"update.dismiss()\">Plus tard</button>\n    </div>\n  </div>\n</div>", styles: [".snack{position:fixed;bottom:0;margin-left:auto;margin-right:auto;left:auto;right:auto;background-color:#ff7a00cc;padding:20px;z-index:2000;border-top:1px solid rgb(255,122,0);font-size:1.5rem;font-weight:700;color:#8b0000;width:100%;text-align:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.UpdateService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGEvc3JjL2xpYi91cGRhdGVzL3VwZGF0ZS91cGRhdGUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGF0YS9zcmMvbGliL3VwZGF0ZXMvdXBkYXRlL3VwZGF0ZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7OztBQUUvQyxNQU9hLGVBQWU7SUFDMUIsWUFBbUIsTUFBcUI7UUFBckIsV0FBTSxHQUFOLE1BQU0sQ0FBZTtJQUFHLENBQUM7OEdBRGpDLGVBQWU7a0dBQWYsZUFBZSx1RUNYNUIsc2RBV00sdVRERk0sWUFBWTs7U0FFWCxlQUFlOzJGQUFmLGVBQWU7a0JBUDNCLFNBQVM7K0JBQ0UsYUFBYSxjQUdYLElBQUksV0FDUCxDQUFDLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVXBkYXRlU2VydmljZSB9IGZyb20gJy4uL3VwZGF0ZS5zZXJ2aWNlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2RhdGEtdXBkYXRlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3VwZGF0ZS5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3VwZGF0ZS5jb21wb25lbnQuc2FzcyddLFxuICBzdGFuZGFsb25lOiB0cnVlLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbn0pXG5leHBvcnQgY2xhc3MgVXBkYXRlQ29tcG9uZW50IHtcbiAgY29uc3RydWN0b3IocHVibGljIHVwZGF0ZTogVXBkYXRlU2VydmljZSkge31cbn1cbiIsIlxuPGRpdiBjbGFzcz1cInNuYWNrXCIgKm5nSWY9XCJ1cGRhdGUuYXZhaWxhYmxlJHxhc3luY1wiPlxuICA8cD5VbmUgbm91dmVsbGUgdmVyc2lvbiBkZSBsJ2FwcGxpY2F0aW9uIGVzdCBkaXNwb25pYmxlLjwvcD5cbiAgPGRpdiBjbGFzcz1cInJvd1wiPlxuICAgIDxkaXYgY2xhc3M9XCJjb2wtc20tNlwiPlxuICAgICAgPGJ1dHRvbiBjbGFzcz1cImJ0biBidG4tcHJpbWFyeSBidG4tYmxvY2sgdy0xMDBcIiAoY2xpY2spPVwidXBkYXRlLmFjdGl2YXRlKClcIj5MJ0FDVElWRVIgTUFJTlRFTkFOVDwvYnV0dG9uPlxuICAgIDwvZGl2PlxuICAgIDxkaXYgY2xhc3M9XCJjb2wtc20tNlwiPlxuICAgICAgPGJ1dHRvbiBjbGFzcz1cImJ0biBidG4td2FybmluZyBidG4tYmxvY2sgdy0xMDBcIiAoY2xpY2spPVwidXBkYXRlLmRpc21pc3MoKVwiPlBsdXMgdGFyZDwvYnV0dG9uPlxuICAgIDwvZGl2PlxuICA8L2Rpdj5cbjwvZGl2PiJdfQ==

package/esm2022/lib/updates/update.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { filter, first, map, tap } from 'rxjs/operators';
+import { merge, ReplaySubject, timer } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/service-worker";
+class UpdateService {
+    constructor(appRef, swUpdate) {
+        this.appRef = appRef;
+        this.swUpdate = swUpdate;
+        this.stable = false;
+        this._available$ = new ReplaySubject(1);
+        this._available$.next(false);
+        const appIsStable$ = this.appRef.isStable
+            .pipe(first((isStable) => isStable))
+            .pipe(tap(() => console.log('App is stable')));
+        const checkInterval$ = timer(10 * 1000, 5 * 60 * 1000);
+        const checkWhenStable$ = merge(appIsStable$, checkInterval$);
+        const updatesAvailable = swUpdate.versionUpdates.pipe(tap((evt) => console.log('Version updates event', evt)), filter((evt) => evt.type === 'VERSION_READY'), map((evt) => ({
+            type: 'UPDATE_AVAILABLE',
+            current: evt.currentVersion,
+            available: evt.latestVersion,
+        })));
+        updatesAvailable.subscribe(async (evt) => {
+            this._available$.next(true);
+        });
+        checkWhenStable$.subscribe(async () => {
+            this.stable = true;
+            try {
+                console.log('Checking for update');
+                const res = await swUpdate.checkForUpdate();
+                console.log('Check for update result', res);
+            }
+            catch (e) {
+                console.warn('No service worker');
+            }
+        });
+    }
+    get available$() {
+        return this._available$.asObservable();
+    }
+    activate() {
+        this._available$.next(false);
+        console.log('RELOADING FULL PAGE');
+        document.location.reload();
+    }
+    dismiss() {
+        this._available$.next(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UpdateService, deps: [{ token: i0.ApplicationRef }, { token: i1.SwUpdate }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UpdateService, providedIn: 'root' }); }
+}
+export { UpdateService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UpdateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i1.SwUpdate }]; } });
+//# sourceMappingURL=data:application/json;base64,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