@solidev/data 0.0.1-dev.0

package/esm2020/lib/modellist/model-list-filters/model-list-filters-select/model-list-filters-select.component.mjs

@@ -0,0 +1,30 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ModelListFiltersSelectComponent {
+    constructor() {
+        this.containerClasses = '';
+        this.itemActiveClasses = 'badge bg-success mx-1';
+        this.itemInactiveClasses = 'badge bg-secondary mx-1';
+    }
+    toggle(f) {
+        f.enabled = !f.enabled;
+        this.list.filters.update();
+    }
+}
+ModelListFiltersSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListFiltersSelectComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ModelListFiltersSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0", type: ModelListFiltersSelectComponent, isStandalone: true, selector: "data-model-list-filters-select", inputs: { list: "list", containerClasses: "containerClasses", itemActiveClasses: "itemActiveClasses", itemInactiveClasses: "itemInactiveClasses" }, ngImport: i0, template: "<span *ngFor=\"let f of list.filters.available|async\" (click)=\"toggle(f)\" [ngClass]=\"containerClasses\"><span *ngIf=\"f.enabled\" role=\"button\" [ngClass]=\"itemActiveClasses\"><i class=\"bi bi-check2-square me-2\"></i><span>{{f.label}}</span></span><span *ngIf=\"!f.enabled\" role=\"button\" [ngClass]=\"itemInactiveClasses\"><i class=\"bi bi-square me-2\"></i><span>{{f.label}}</span></span></span>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListFiltersSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-filters-select', standalone: true, imports: [CommonModule], template: "<span *ngFor=\"let f of list.filters.available|async\" (click)=\"toggle(f)\" [ngClass]=\"containerClasses\"><span *ngIf=\"f.enabled\" role=\"button\" [ngClass]=\"itemActiveClasses\"><i class=\"bi bi-check2-square me-2\"></i><span>{{f.label}}</span></span><span *ngIf=\"!f.enabled\" role=\"button\" [ngClass]=\"itemInactiveClasses\"><i class=\"bi bi-square me-2\"></i><span>{{f.label}}</span></span></span>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], containerClasses: [{
+                type: Input
+            }], itemActiveClasses: [{
+                type: Input
+            }], itemInactiveClasses: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modellist/model-list-filters/model-list-filters.mjs

@@ -0,0 +1,80 @@
+import { ReplaySubject } from 'rxjs';
+export class ModelListFilters {
+    constructor(params) {
+        this._output = new ReplaySubject(1);
+        this._enabled = new ReplaySubject(1);
+        this._available = new ReplaySubject(1);
+        const tmp = Array.from(params?.filters || []);
+        // Prepare allowed filters (all filters if not set or empty)
+        let allowed = [];
+        if (params?.allowed === undefined || params?.allowed === []) {
+            for (const f of tmp) {
+                allowed.push(f.name);
+            }
+        }
+        else {
+            allowed = params.allowed;
+        }
+        // Prepare excluded filters
+        const excluded = params?.excluded || [];
+        // Process default filters
+        // Use all allowed filters if empty of not set
+        const defaults = params?.defaults || allowed;
+        // Prepare filters status
+        // Set allowed
+        for (const fe of allowed) {
+            for (const f of tmp) {
+                if (f.name === fe) {
+                    f.allowed = true;
+                }
+            }
+        }
+        // Set defaults
+        for (const fe of defaults) {
+            for (const f of tmp) {
+                if (f.name === fe) {
+                    f.enabled = true;
+                    f.allowed = true;
+                }
+            }
+        }
+        // remove excluded
+        for (const fe of excluded) {
+            for (const f of tmp) {
+                if (f.name === fe) {
+                    f.enabled = false;
+                    f.allowed = false;
+                }
+            }
+        }
+        this._filters = tmp;
+        this.update();
+    }
+    get output() {
+        return this._output.asObservable();
+    }
+    get enabled() {
+        return this._enabled.asObservable();
+    }
+    get available() {
+        return this._available.asObservable();
+    }
+    update() {
+        const filter = {};
+        const enabled = [];
+        const available = [];
+        for (const f of this._filters) {
+            if (f.enabled) {
+                f.updateFilter(filter);
+                enabled.push(f);
+            }
+            if (f.allowed) {
+                available.push(f);
+            }
+        }
+        this._output.next(filter);
+        this._enabled.next(enabled);
+        this._available.next(available);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,70 @@
+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";
+export 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);
+            });
+        }
+    }
+}
+ModelListPaginatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListPaginatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ModelListPaginatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.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"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.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 {\n  FormControl,\n  ReactiveFormsModule,\n  UntypedFormControl,\n} from '@angular/forms';\nimport { debounceTime, Subject, takeUntil } from 'rxjs';\nimport { NgbPaginationModule } from '@ng-bootstrap/ng-bootstrap';\nimport { CommonModule } from '@angular/common';\nimport { DataSource } from '@angular/cdk/collections';\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\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/esm2020/lib/modellist/model-list-paginator/model-list-paginator.mjs

@@ -0,0 +1,47 @@
+import { ReplaySubject } from 'rxjs';
+export class ModelListPaginator {
+    constructor(defaults) {
+        this._output = new ReplaySubject(1);
+        if (!defaults) {
+            defaults = { page_size: 20, page: 1 };
+        }
+        this._page_size = defaults.page_size || 20;
+        this._page = defaults.page || 1;
+        this._updateOutput('constructor');
+    }
+    get output() {
+        return this._output.asObservable();
+    }
+    setPage(page) {
+        if (page !== this._page) {
+            this._page = page;
+            this._updateOutput('setPage');
+        }
+    }
+    updatePage(page) {
+        if (page !== this._page) {
+            this._page = page;
+        }
+    }
+    setPageSize(size) {
+        if (size !== this._page_size) {
+            this._page_size = size;
+            this._updateOutput('setPageSize');
+        }
+    }
+    updatePageSize(size) {
+        if (size !== this._page_size) {
+            this._page_size = size;
+        }
+    }
+    getPageSize() {
+        return this._page_size;
+    }
+    getPage() {
+        return this._page;
+    }
+    _updateOutput(from = '') {
+        this._output.next({ page: this._page, page_size: this._page_size });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,49 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export 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);
+    }
+}
+ModelListSorterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListSorterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ModelListSorterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.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"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.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/esm2020/lib/modellist/model-list-sorter/model-list-sorter.mjs

@@ -0,0 +1,116 @@
+import { ReplaySubject } from 'rxjs';
+export class ModelListSorter {
+    /**
+     * Create ModelListSorter instance, using defaults.
+     * @param defaults defaults sort values, as a list of strings (+field, -field, field)
+     */
+    constructor(defaults = []) {
+        this._values = [];
+        this._output = new ReplaySubject(1);
+        this._values = [];
+        for (const d of defaults) {
+            if (d.length < 1) {
+                continue;
+            }
+            if (d[0] == '+') {
+                this._values.push({ field: d.substring(1), direction: 'asc' });
+            }
+            else if (d[0] == '-') {
+                this._values.push({ field: d.substring(1), direction: 'desc' });
+            }
+            else {
+                this._values.push({ field: d, direction: 'asc' });
+            }
+        }
+        this._updateOutput('constructor');
+    }
+    /**
+     * Returns a list of "+/-field" sort strings observable.
+     * @returns sort strings observable
+     */
+    get output() {
+        return this._output.asObservable();
+    }
+    /**
+     * Set sorting for `name` key, in direction `direction`.
+     * If sorting is already set for `name` key, updates direction without changing order.
+     * If sorting isn't set for `name` key, adds it at the end of sorting directions.
+     *
+     * @param name field name
+     * @param direction sort direction
+     * @returns model list sorter
+     */
+    set(name, direction) {
+        for (const v of this._values) {
+            if (v.field === name) {
+                v.direction = direction;
+                this._updateOutput();
+                return this;
+            }
+        }
+        this._values.push({ field: name, direction });
+        this._updateOutput('set');
+        return this;
+    }
+    /**
+     * Removes `name` sorting key from current keys.
+     *
+     * @param  name sort key to be removed
+     * @returns model list sorter
+     */
+    unset(name) {
+        for (let i = 0; i < this._values.length; i++) {
+            if (this._values[i].field === name) {
+                this._values.splice(i, 1);
+                break;
+            }
+        }
+        this._updateOutput('unset');
+        return this;
+    }
+    /**
+     * Get sorting status for `field` argument.
+     * If `field` is not found, returns null.
+     *
+     * @param  field field name
+     * @returns ordering direction / null
+     */
+    get(field) {
+        for (const v of this._values) {
+            if (v.field === field) {
+                return v;
+            }
+        }
+        return null;
+    }
+    /**
+     * Return all sorter data values.
+     *
+     * @returns all sorter data values.
+     */
+    getAll() {
+        return this._values;
+    }
+    /**
+     * Get the ordering position for `field` argument. If not found, returns -1.
+     *
+     * @param  field field name
+     * @returns ordering position for field
+     */
+    getOrder(field) {
+        for (let i = 0; i < this._values.length; i++) {
+            if (this._values[i].field === field) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+    _updateOutput(_from = '') {
+        let out = [];
+        for (const v of this._values) {
+            out.push(`${v.direction === 'asc' ? '' : '-'}${v.field}`);
+        }
+        this._output.next(out);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list-sorter.js","sourceRoot":"","sources":["../../../../../../projects/data/src/lib/modellist/model-list-sorter/model-list-sorter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, ReplaySubject } from 'rxjs';\nimport { SorterDefaults } from '../model-list.service';\n\n// TODO: add an option to limit the number of ordering fields (eg. for tree queries)\nexport type SortDirection = 'asc' | 'desc';\n\nexport interface FieldSortData {\n  field: string;\n  direction: SortDirection;\n}\n\nexport type SorterData = FieldSortData[];\n\nexport class ModelListSorter {\n  private readonly _values: SorterData = [];\n\n  /**\n   * Create ModelListSorter instance, using defaults.\n   * @param defaults defaults sort values, as a list of strings (+field, -field, field)\n   */\n  constructor(defaults: SorterDefaults = []) {\n    this._output = new ReplaySubject(1);\n    this._values = [];\n    for (const d of defaults) {\n      if (d.length < 1) {\n        continue;\n      }\n      if (d[0] == '+') {\n        this._values.push({ field: d.substring(1), direction: 'asc' });\n      } else if (d[0] == '-') {\n        this._values.push({ field: d.substring(1), direction: 'desc' });\n      } else {\n        this._values.push({ field: d, direction: 'asc' });\n      }\n    }\n    this._updateOutput('constructor');\n  }\n\n  private _output: ReplaySubject<string[]>;\n\n  /**\n   * Returns a list of \"+/-field\" sort strings observable.\n   * @returns sort strings observable\n   */\n  public get output(): Observable<string[]> {\n    return this._output.asObservable();\n  }\n\n  /**\n   * Set sorting for `name` key, in direction `direction`.\n   * If sorting is already set for `name` key, updates direction without changing order.\n   * If sorting isn't set for `name` key, adds it at the end of sorting directions.\n   *\n   * @param name field name\n   * @param direction sort direction\n   * @returns model list sorter\n   */\n  public set(name: string, direction: SortDirection): ModelListSorter {\n    for (const v of this._values) {\n      if (v.field === name) {\n        v.direction = direction;\n        this._updateOutput();\n        return this;\n      }\n    }\n    this._values.push({ field: name, direction });\n    this._updateOutput('set');\n    return this;\n  }\n\n  /**\n   * Removes `name` sorting key from current keys.\n   *\n   * @param  name sort key to be removed\n   * @returns model list sorter\n   */\n  public unset(name: string): ModelListSorter {\n    for (let i = 0; i < this._values.length; i++) {\n      if (this._values[i].field === name) {\n        this._values.splice(i, 1);\n        break;\n      }\n    }\n    this._updateOutput('unset');\n    return this;\n  }\n\n  /**\n   * Get sorting status for `field` argument.\n   * If `field` is not found, returns null.\n   *\n   * @param  field field name\n   * @returns ordering direction / null\n   */\n  public get(field: string): FieldSortData | null {\n    for (const v of this._values) {\n      if (v.field === field) {\n        return v;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Return all sorter data values.\n   *\n   * @returns all sorter data values.\n   */\n  public getAll(): SorterData {\n    return this._values;\n  }\n\n  /**\n   * Get the ordering position for `field` argument. If not found, returns -1.\n   *\n   * @param  field field name\n   * @returns ordering position for field\n   */\n  public getOrder(field: string): number {\n    for (let i = 0; i < this._values.length; i++) {\n      if (this._values[i].field === field) {\n        return i + 1;\n      }\n    }\n    return -1;\n  }\n\n  private _updateOutput(_from: string = ''): void {\n    let out: string[] = [];\n    for (const v of this._values) {\n      out.push(`${v.direction === 'asc' ? '' : '-'}${v.field}`);\n    }\n    this._output.next(out);\n  }\n}\n"]}

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

@@ -0,0 +1,115 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, debounceTime, of, Subject, takeUntil, } from 'rxjs';
+import { switchMap } 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 * as i0 from "@angular/core";
+export class ModelList {
+    constructor(name) {
+        this.started = false;
+        this.name = name;
+    }
+    get results() {
+        return this.queryset.results;
+    }
+    get meta() {
+        return this.queryset.meta;
+    }
+    get loading() {
+        return this.queryset.loading;
+    }
+    get full() {
+        return this.queryset.full;
+    }
+    start(params) {
+        let filter$;
+        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,
+            this.filters.output,
+            filter$,
+            this.paginator.output,
+            this.sorter.output,
+            this.fields.output,
+        ])
+            .pipe(takeUntil(this.unsubscribe), debounceTime(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);
+            return this.queryset.get(true);
+        }))
+            .subscribe({
+            next: (results) => { },
+            error: (error) => {
+                console.error('Error while getting model list results : ', error);
+            },
+            complete: () => {
+                console.log('modellist:completed', this.name);
+                this.started = false;
+            },
+        });
+        this.reload.next();
+        this.started = true;
+    }
+}
+export class ModelListService {
+    constructor() {
+        this._instances = {};
+    }
+    get(name, collection, defaults) {
+        let ml;
+        if (!name || !this._instances[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[name] = ml;
+            }
+        }
+        else {
+            ml = this._instances[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;
+    }
+}
+ModelListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ModelListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ModelListService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# 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":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  combineLatest,\n  debounceTime,\n  Observable,\n  of,\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 } 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';\n\nexport interface CustomField {\n  name: string;\n  label: string;\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 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>;\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>;\n  public unsubscribe!: Subject<void>;\n  public started = false;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  public get results(): Observable<T[]> {\n    return this.queryset.results;\n  }\n\n  public get meta(): Observable<IQueryMeta> {\n    return this.queryset.meta;\n  }\n\n  public get loading(): Observable<boolean> {\n    return this.queryset.loading;\n  }\n\n  public get full(): Observable<[T[], boolean, IQueryMeta]> {\n    return this.queryset.full;\n  }\n\n  public start(params: ModelListParams) {\n    let filter$: Observable<FilterDefaults>;\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,\n      this.filters.output,\n      filter$,\n      this.paginator.output,\n      this.sorter.output,\n      this.fields.output,\n    ])\n      .pipe(\n        takeUntil(this.unsubscribe),\n        debounceTime(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            return this.queryset.get(true);\n          }\n        )\n      )\n      .subscribe({\n        next: (results: any): void => {},\n        error: (error) => {\n          console.error('Error while getting model list results : ', error);\n        },\n        complete: () => {\n          console.log('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: { [index: string]: ModelList<any> } = {};\n\n  constructor() {}\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[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[name] = ml;\n      }\n    } else {\n      ml = this._instances[name];\n    }\n    if (!ml.started) {\n      if (defaults.reload) {\n        ml.reload = defaults.reload;\n      } else {\n        ml.reload = new Subject<void>();\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"]}