@solidev/data 0.0.8 → 0.1.0

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

@@ -0,0 +1,57 @@
+import { Component, Input } from '@angular/core';
+import { combineLatest, debounceTime } from 'rxjs';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+class ModelListSelectFilterComponent {
+    constructor() {
+        this.classes = '';
+        this.fc = new FormControl(null);
+    }
+    ngOnInit() {
+        this.filter.valueChanges.subscribe((val) => {
+            this.fc.setValue(val ? val.value : null, {
+                emitEvent: false,
+            });
+        });
+        combineLatest([
+            this.filter.choices,
+            this.fc.valueChanges.pipe(debounceTime(250)),
+        ]).subscribe(([choices, val]) => {
+            if (val === null) {
+                this.filter.clear();
+                this.list.filters.update();
+            }
+            else {
+                for (const ch of choices) {
+                    if (ch.value === val) {
+                        if (this.filter.set(ch.value, ch.desc)) {
+                            this.list.filters.update();
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+    }
+    disable() {
+        this.filter.enabled = false;
+        this.list.filters.update();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSelectFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListSelectFilterComponent, isStandalone: true, selector: "data-model-list-select-filter", inputs: { list: "list", filter: "filter", classes: "classes" }, ngImport: i0, template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <select class=\"form-select\" [formControl]=\"fc\">\n    <option [ngValue]=\"null\">-- {{filter.help}} --</option>\n    <option *ngFor=\"let c of filter.choices|async\" [ngValue]=\"c.value\">{{c.desc}}</option>\n  </select>\n</div>", 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: "pipe", type: i1.AsyncPipe, name: "async" }, { 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.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"] }] }); }
+}
+export { ModelListSelectFilterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSelectFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-select-filter', standalone: true, imports: [CommonModule, ReactiveFormsModule], template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <select class=\"form-select\" [formControl]=\"fc\">\n    <option [ngValue]=\"null\">-- {{filter.help}} --</option>\n    <option *ngFor=\"let c of filter.choices|async\" [ngValue]=\"c.value\">{{c.desc}}</option>\n  </select>\n</div>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], classes: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modellist/model-list-filters/filters/model-list-select-multi-filter/model-list-select-multi-filter.component.mjs

@@ -0,0 +1,52 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { combineLatest, debounceTime } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+class ModelListSelectMultiFilterComponent {
+    constructor() {
+        this.classes = '';
+        this.fc = new FormControl(null);
+    }
+    ngOnInit() {
+        combineLatest([
+            this.filter.choices,
+            this.fc.valueChanges.pipe(debounceTime(250)),
+        ]).subscribe(([choices, val]) => {
+            for (const ch of choices) {
+                if (ch.value === val) {
+                    if (this.filter.set(ch.value, ch.desc)) {
+                        this.list.filters.update();
+                        break;
+                    }
+                }
+            }
+            this.fc.setValue(null, { emitEvent: false });
+        });
+    }
+    unset(value, desc) {
+        this.fc.setValue(null);
+        this.filter.unset(value, desc);
+        this.list.filters.update();
+    }
+    disable() {
+        this.filter.enabled = false;
+        this.list.filters.update();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSelectMultiFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListSelectMultiFilterComponent, isStandalone: true, selector: "data-model-list-select-multi-filter", inputs: { list: "list", filter: "filter", classes: "classes" }, ngImport: i0, template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <select class=\"form-select\" [formControl]=\"fc\">\n    <option [ngValue]=\"null\">-- {{filter.help}} --</option>\n    <option *ngFor=\"let c of filter.choices|async\" [ngValue]=\"c.value\">{{c.desc}}</option>\n  </select>\n  <div class=\"enabled mt-1\">\n    <div *ngFor=\"let e of filter.mcurrent$|async\"><i class=\"bi bi-trash me-2\" (click)=\"unset(e.value, e.desc)\" role=\"button\"></i>{{e.desc}}</div>\n  </div>\n</div>", 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: "pipe", type: i1.AsyncPipe, name: "async" }, { 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.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"] }] }); }
+}
+export { ModelListSelectMultiFilterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListSelectMultiFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-select-multi-filter', standalone: true, imports: [CommonModule, ReactiveFormsModule], template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <select class=\"form-select\" [formControl]=\"fc\">\n    <option [ngValue]=\"null\">-- {{filter.help}} --</option>\n    <option *ngFor=\"let c of filter.choices|async\" [ngValue]=\"c.value\">{{c.desc}}</option>\n  </select>\n  <div class=\"enabled mt-1\">\n    <div *ngFor=\"let e of filter.mcurrent$|async\"><i class=\"bi bi-trash me-2\" (click)=\"unset(e.value, e.desc)\" role=\"button\"></i>{{e.desc}}</div>\n  </div>\n</div>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], classes: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modellist/model-list-filters/filters/model-list-text-filter/model-list-text-filter.component.mjs

@@ -0,0 +1,41 @@
+import { Component, Input } from '@angular/core';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { debounceTime } from 'rxjs';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+class ModelListTextFilterComponent {
+    constructor() {
+        this.classes = '';
+        this.fc = new FormControl(null);
+    }
+    ngOnInit() {
+        this.filter.valueChanges.subscribe((val) => {
+            this.fc.setValue(val.value, { emitEvent: false });
+        });
+        this.fc.valueChanges.pipe(debounceTime(250)).subscribe((val) => {
+            if (this.filter.set(val, val || '')) {
+                this.list.filters.update();
+            }
+        });
+    }
+    disable() {
+        this.filter.enabled = false;
+        this.list.filters.update();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListTextFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListTextFilterComponent, isStandalone: true, selector: "data-model-list-text-filter", inputs: { list: "list", filter: "filter", classes: "classes" }, ngImport: i0, template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <input class=\"form-control\" type=\"text\" [formControl]=\"fc\" [placeholder]=\"filter.help\">\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { 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.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }] }); }
+}
+export { ModelListTextFilterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListTextFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-text-filter', standalone: true, imports: [CommonModule, ReactiveFormsModule], template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <input class=\"form-control\" type=\"text\" [formControl]=\"fc\" [placeholder]=\"filter.help\">\n</div>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], classes: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modellist/model-list-filters/filters/model-list-tree-filter/model-list-tree-filter.component.mjs

@@ -0,0 +1,175 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormControl, ReactiveFormsModule } from '@angular/forms';
+import { debounceTime, firstValueFrom, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+class Level {
+    constructor(tree, level, choices) {
+        this.tree = tree;
+        this.level = level;
+        this.fc = new FormControl('');
+        this.choices = choices;
+        this.subs = this.fc.valueChanges.subscribe((val) => {
+            if (this.selected !== val) {
+                this.selected = val;
+                this.tree.updated(this);
+            }
+        });
+    }
+    close() {
+        this.subs.unsubscribe();
+    }
+}
+class Tree {
+    constructor(qs, maxLevel, display, filter) {
+        this.qs = qs;
+        this.maxLevel = maxLevel;
+        this.display = display;
+        this.filter = filter;
+        this.levels = [];
+        this.changed = new Subject();
+    }
+    /**
+     * Conditionnaly add level to current tree.
+     *
+     * - if previous level have non-empty selected value
+     * - if current level choices are non empty
+     */
+    async addLevel(fparent) {
+        let values = [];
+        if (this.levels.length === 0) {
+            values = await firstValueFrom(this.qs
+                .filter({ level: this.levels.length, parent: 'null', ...this.filter })
+                .get());
+        }
+        else {
+            const parent = fparent
+                ? fparent
+                : this.levels[this.levels.length - 1].selected;
+            if (parent) {
+                values = await firstValueFrom(this.qs
+                    .filter({
+                    level: this.levels.length,
+                    parent: this.levels[this.levels.length - 1].selected || 'null',
+                    ...this.filter,
+                })
+                    .get());
+            }
+        }
+        if (values.length > 0) {
+            const level = new Level(this, this.levels.length, []);
+            for (const v of values) {
+                level.choices.push({ value: v.id, desc: this.display(v) });
+            }
+            this.levels.push(level);
+            return level;
+        }
+        return null;
+    }
+    updated(level) {
+        const newLevels = [];
+        for (const l of this.levels) {
+            if (l.level <= level.level) {
+                newLevels.push(l);
+            }
+            else if (l.level > level.level) {
+                l.close();
+            }
+        }
+        this.levels = newLevels;
+        this.addLevel();
+        if (level.selected) {
+            this.changed.next(level.selected);
+        }
+        else {
+            this.changed.next(this.levels[level.level - 1]?.selected || null);
+        }
+    }
+    async prepare(value) {
+        // console.log('prepare', value);
+        const levels = [];
+        let cur = (await firstValueFrom(this.qs.filter({ id: value, ...this.filter }).get()))[0];
+        levels.push(cur);
+        let nlev = 0;
+        while (cur.parent !== null) {
+            cur = (await firstValueFrom(this.qs
+                .filter({
+                id: cur.parent,
+                ...this.filter,
+            })
+                .get()))[0];
+            levels.push(cur);
+            nlev++;
+            if (nlev > this.maxLevel) {
+                throw Error('Max level error, could not find root');
+            }
+        }
+        for (let i = levels.length - 1; i >= 0; i--) {
+            const lv = await this.addLevel();
+            if (lv !== null) {
+                lv.selected = levels[i].id;
+                lv.fc.setValue(levels[i].id, { emitEvent: false });
+            }
+        }
+        if (this.levels.length <= this.maxLevel) {
+            await this.addLevel();
+        }
+    }
+    reset() { }
+}
+class ModelListTreeFilterComponent {
+    constructor() {
+        this.classes = '';
+    }
+    async ngOnInit() {
+        this.tree = new Tree(this.filter.queryset, this.filter.maxLevel, this.filter.display, this.filter.filter);
+        if (this.filter.get()) {
+            await this.tree.prepare(this.filter.get()?.value);
+        }
+        else {
+            await this.tree.addLevel();
+        }
+        this.tree.changed.pipe(debounceTime(250)).subscribe((val) => {
+            // console.log('changed', val);
+            if (val === null) {
+                this.filter.clear();
+                this.list.filters.update();
+            }
+            else {
+                if (this.filter.set(val, '')) {
+                    this.list.filters.update();
+                }
+            }
+        });
+        // this.tree.changed.subscribe((selected) => {
+        //   console.log('tree changed', selected);
+        //   this.filter.set(selected, '');
+        // });
+        // if (this.filter.getValue()) {
+        //   console.log('filter value', this.filter.getValue());
+        //   await this.tree.prepare(this.filter.getValue() as number);
+        // } else {
+        //   await this.tree.addLevel();
+        // }
+    }
+    disable() {
+        this.filter.enabled = false;
+        this.list.filters.update();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListTreeFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListTreeFilterComponent, isStandalone: true, selector: "data-model-list-tree-filter", inputs: { list: "list", filter: "filter", classes: "classes" }, ngImport: i0, template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <div class=\"levelselect\" *ngFor=\"let l of tree.levels\">\n    <select class=\"form-select form-select-sm\" [formControl]=\"l.fc\">\n      <option value=\"\">{{filter.help}}</option>\n      <option *ngFor=\"let ch of l.choices\" [value]=\"ch.value\">{{ch.desc}}</option>\n    </select>\n  </div>\n</div>", 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: "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.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"] }] }); }
+}
+export { ModelListTreeFilterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListTreeFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-tree-filter', standalone: true, imports: [CommonModule, ReactiveFormsModule], template: "\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <div class=\"levelselect\" *ngFor=\"let l of tree.levels\">\n    <select class=\"form-select form-select-sm\" [formControl]=\"l.fc\">\n      <option value=\"\">{{filter.help}}</option>\n      <option *ngFor=\"let ch of l.choices\" [value]=\"ch.value\">{{ch.desc}}</option>\n    </select>\n  </div>\n</div>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { list: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], classes: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list-tree-filter.component.js","sourceRoot":"","sources":["../../../../../../../../projects/data/src/lib/modellist/model-list-filters/filters/model-list-tree-filter/model-list-tree-filter.component.ts","../../../../../../../../projects/data/src/lib/modellist/model-list-filters/filters/model-list-tree-filter/model-list-tree-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit } from '@angular/core';\nimport { ModelList } from '../../../model-list.service';\nimport { ModelListTreeFilter } from './model-list-tree-filter';\nimport { CommonModule } from '@angular/common';\nimport { DataModel } from '../../../../data/data-model';\nimport { FormControl, ReactiveFormsModule } from '@angular/forms';\nimport { debounceTime, firstValueFrom, Subject, Subscription } from 'rxjs';\nimport { FilterData, Queryset } from '../../../../data/data-query';\n\nclass Level<T extends DataModel> {\n  public level: number;\n  public tree: Tree<T>;\n  public choices: { value: number; desc: string }[];\n  public fc: FormControl;\n  public selected!: number;\n  public subs: Subscription;\n\n  constructor(\n    tree: Tree<T>,\n    level: number,\n    choices: { value: number; desc: string }[]\n  ) {\n    this.tree = tree;\n    this.level = level;\n    this.fc = new FormControl('');\n    this.choices = choices;\n    this.subs = this.fc.valueChanges.subscribe((val) => {\n      if (this.selected !== val) {\n        this.selected = val;\n        this.tree.updated(this);\n      }\n    });\n  }\n\n  public close() {\n    this.subs.unsubscribe();\n  }\n}\n\nclass Tree<T extends DataModel> {\n  levels: Level<T>[] = [];\n  changed: Subject<number | null> = new Subject<number | null>();\n\n  constructor(\n    private qs: Queryset<T>,\n    private maxLevel: number,\n    private display: any,\n    private filter: FilterData\n  ) {}\n\n  /**\n   * Conditionnaly add level to current tree.\n   *\n   * - if previous level have non-empty selected value\n   * - if current level choices are non empty\n   */\n  public async addLevel(fparent?: number): Promise<Level<T> | null> {\n    let values: T[] = [];\n    if (this.levels.length === 0) {\n      values = await firstValueFrom(\n        this.qs\n          .filter({ level: this.levels.length, parent: 'null', ...this.filter })\n          .get()\n      );\n    } else {\n      const parent = fparent\n        ? fparent\n        : this.levels[this.levels.length - 1].selected;\n      if (parent) {\n        values = await firstValueFrom(\n          this.qs\n            .filter({\n              level: this.levels.length,\n              parent: this.levels[this.levels.length - 1].selected || 'null',\n              ...this.filter,\n            })\n            .get()\n        );\n      }\n    }\n    if (values.length > 0) {\n      const level = new Level(this, this.levels.length, []);\n      for (const v of values) {\n        level.choices.push({ value: v.id as number, desc: this.display(v) });\n      }\n      this.levels.push(level);\n      return level;\n    }\n    return null;\n  }\n\n  public updated(level: Level<T>) {\n    const newLevels: Level<T>[] = [];\n    for (const l of this.levels) {\n      if (l.level <= level.level) {\n        newLevels.push(l);\n      } else if (l.level > level.level) {\n        l.close();\n      }\n    }\n    this.levels = newLevels;\n    this.addLevel();\n    if (level.selected) {\n      this.changed.next(level.selected);\n    } else {\n      this.changed.next(this.levels[level.level - 1]?.selected || null);\n    }\n  }\n\n  public async prepare(value: number) {\n    // console.log('prepare', value);\n    const levels: T[] = [];\n    let cur = (\n      await firstValueFrom(this.qs.filter({ id: value, ...this.filter }).get())\n    )[0];\n    levels.push(cur);\n    let nlev = 0;\n    while ((cur as any).parent !== null) {\n      cur = (\n        await firstValueFrom(\n          this.qs\n            .filter({\n              id: (cur as any).parent,\n              ...this.filter,\n            })\n            .get()\n        )\n      )[0];\n      levels.push(cur);\n      nlev++;\n      if (nlev > this.maxLevel) {\n        throw Error('Max level error, could not find root');\n      }\n    }\n    for (let i = levels.length - 1; i >= 0; i--) {\n      const lv = await this.addLevel();\n      if (lv !== null) {\n        lv.selected = levels[i].id as number;\n        lv.fc.setValue(levels[i].id as number, { emitEvent: false });\n      }\n    }\n    if (this.levels.length <= this.maxLevel) {\n      await this.addLevel();\n    }\n  }\n\n  public reset() {}\n}\n\n@Component({\n  selector: 'data-model-list-tree-filter',\n  templateUrl: './model-list-tree-filter.component.html',\n  styleUrls: ['./model-list-tree-filter.component.sass'],\n  standalone: true,\n  imports: [CommonModule, ReactiveFormsModule],\n})\nexport class ModelListTreeFilterComponent<T extends DataModel>\n  implements OnInit\n{\n  @Input() public list!: ModelList<any>;\n  @Input() public filter!: ModelListTreeFilter<T>;\n  @Input() public classes: string[] | string = '';\n  public tree!: Tree<T>;\n\n  constructor() {}\n\n  public async ngOnInit() {\n    this.tree = new Tree(\n      this.filter.queryset,\n      this.filter.maxLevel,\n      this.filter.display,\n      this.filter.filter\n    );\n    if (this.filter.get()) {\n      await this.tree.prepare(this.filter.get()?.value as number);\n    } else {\n      await this.tree.addLevel();\n    }\n\n    this.tree.changed.pipe(debounceTime(250)).subscribe((val) => {\n      // console.log('changed', val);\n      if (val === null) {\n        this.filter.clear();\n        this.list.filters.update();\n      } else {\n        if (this.filter.set(val, '')) {\n          this.list.filters.update();\n        }\n      }\n    });\n\n    // this.tree.changed.subscribe((selected) => {\n    //   console.log('tree changed', selected);\n    //   this.filter.set(selected, '');\n    // });\n    // if (this.filter.getValue()) {\n    //   console.log('filter value', this.filter.getValue());\n    //   await this.tree.prepare(this.filter.getValue() as number);\n    // } else {\n    //   await this.tree.addLevel();\n    // }\n  }\n\n  public disable() {\n    this.filter.enabled = false;\n    this.list.filters.update();\n  }\n}\n","\n<div class=\"filteritem\" [ngClass]=\"filter.displayClasses || classes\">\n  <div class=\"trash float-end\" (click)=\"disable()\"><i class=\"bi bi-trash\"></i></div>\n  <label>{{filter.label}}</label>\n  <div class=\"levelselect\" *ngFor=\"let l of tree.levels\">\n    <select class=\"form-select form-select-sm\" [formControl]=\"l.fc\">\n      <option value=\"\">{{filter.help}}</option>\n      <option *ngFor=\"let ch of l.choices\" [value]=\"ch.value\">{{ch.desc}}</option>\n    </select>\n  </div>\n</div>"]}

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

@@ -0,0 +1,51 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ModelListTextFilterComponent } from '../filters/model-list-text-filter/model-list-text-filter.component';
+import { ModelListAutocompleteFilterComponent } from '../filters/model-list-autocomplete-filter/model-list-autocomplete-filter.component';
+import { ModelListAutocompleteMultiFilterComponent } from '../filters/model-list-autocomplete-multi-filter/model-list-autocomplete-multi-filter.component';
+import { ModelListDatetimeFilterComponent } from '../filters/model-list-datetime-filter/model-list-datetime-filter.component';
+import { ModelListDatetimeRangeFilterComponent } from '../filters/model-list-datetimerange-filter/model-list-datetime-range-filter.component';
+import { ModelListFlagsFilterComponent } from '../filters/model-list-flags-filter/model-list-flags-filter.component';
+import { ModelListGeodistanceFilterComponent } from '../filters/model-list-geodistance-filter/model-list-geodistance-filter.component';
+import { ModelListSelectFilterComponent } from '../filters/model-list-select-filter/model-list-select-filter.component';
+import { ModelListSelectMultiFilterComponent } from '../filters/model-list-select-multi-filter/model-list-select-multi-filter.component';
+import { ModelListTreeFilterComponent } from '../filters/model-list-tree-filter/model-list-tree-filter.component';
+import { ModelListNumberFilterComponent } from '../filters/model-list-number-filter/model-list-number-filter.component';
+import { ModelListDateFilterComponent } from '../filters/model-list-date-filter/model-list-date-filter.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+// FIXME: register filter components and load them dynamically to allow user defined filters
+class ModelListFiltersComponent {
+    constructor() {
+        this.containerClasses = '';
+        this.itemClasses = '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListFiltersComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: ModelListFiltersComponent, isStandalone: true, selector: "data-model-list-filters", inputs: { list: "list", containerClasses: "containerClasses", itemClasses: "itemClasses" }, ngImport: i0, template: "\n<div [ngClass]=\"containerClasses\">\n  <ng-container *ngFor=\"let f of list.filters.enabled|async\">\n    <ng-container [ngSwitch]=\"f.type\">\n      <data-model-list-autocomplete-filter *ngSwitchCase=\"'autocomplete'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-filter>\n      <data-model-list-autocomplete-multi-filter *ngSwitchCase=\"'autocompletemulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-multi-filter>\n      <data-model-list-datetime-filter *ngSwitchCase=\"'datetime'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-filter>\n      <data-model-list-date-filter *ngSwitchCase=\"'date'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-date-filter>\n      <data-model-list-datetime-range-filter *ngSwitchCase=\"'datetimerange'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-range-filter>\n      <data-model-list-flags-filter *ngSwitchCase=\"'flags'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-flags-filter>\n      <data-model-list-geodistance-filter *ngSwitchCase=\"'geodistance'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-geodistance-filter>\n      <data-model-list-number-filter *ngSwitchCase=\"'number'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-number-filter>\n      <data-model-list-select-filter *ngSwitchCase=\"'select'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-filter>\n      <data-model-list-select-multi-filter *ngSwitchCase=\"'selectmulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-multi-filter>\n      <data-model-list-text-filter *ngSwitchCase=\"'text'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-text-filter>\n      <data-model-list-tree-filter *ngSwitchCase=\"'tree'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-tree-filter>\n    </ng-container>\n  </ng-container>\n</div>", 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.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i1.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "component", type: ModelListTextFilterComponent, selector: "data-model-list-text-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListNumberFilterComponent, selector: "data-model-list-number-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListAutocompleteFilterComponent, selector: "data-model-list-autocomplete-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListAutocompleteMultiFilterComponent, selector: "data-model-list-autocomplete-multi-filter", inputs: ["filter"] }, { kind: "component", type: ModelListDatetimeFilterComponent, selector: "data-model-list-datetime-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListDateFilterComponent, selector: "data-model-list-date-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListDatetimeRangeFilterComponent, selector: "data-model-list-datetime-range-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListFlagsFilterComponent, selector: "data-model-list-flags-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListGeodistanceFilterComponent, selector: "data-model-list-geodistance-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListSelectFilterComponent, selector: "data-model-list-select-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListSelectMultiFilterComponent, selector: "data-model-list-select-multi-filter", inputs: ["list", "filter", "classes"] }, { kind: "component", type: ModelListTreeFilterComponent, selector: "data-model-list-tree-filter", inputs: ["list", "filter", "classes"] }] }); }
+}
+export { ModelListFiltersComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListFiltersComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'data-model-list-filters', standalone: true, imports: [
+                        CommonModule,
+                        ModelListTextFilterComponent,
+                        ModelListNumberFilterComponent,
+                        ModelListAutocompleteFilterComponent,
+                        ModelListAutocompleteMultiFilterComponent,
+                        ModelListDatetimeFilterComponent,
+                        ModelListDateFilterComponent,
+                        ModelListDatetimeRangeFilterComponent,
+                        ModelListFlagsFilterComponent,
+                        ModelListGeodistanceFilterComponent,
+                        ModelListSelectFilterComponent,
+                        ModelListSelectMultiFilterComponent,
+                        ModelListTreeFilterComponent,
+                    ], template: "\n<div [ngClass]=\"containerClasses\">\n  <ng-container *ngFor=\"let f of list.filters.enabled|async\">\n    <ng-container [ngSwitch]=\"f.type\">\n      <data-model-list-autocomplete-filter *ngSwitchCase=\"'autocomplete'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-filter>\n      <data-model-list-autocomplete-multi-filter *ngSwitchCase=\"'autocompletemulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-multi-filter>\n      <data-model-list-datetime-filter *ngSwitchCase=\"'datetime'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-filter>\n      <data-model-list-date-filter *ngSwitchCase=\"'date'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-date-filter>\n      <data-model-list-datetime-range-filter *ngSwitchCase=\"'datetimerange'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-range-filter>\n      <data-model-list-flags-filter *ngSwitchCase=\"'flags'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-flags-filter>\n      <data-model-list-geodistance-filter *ngSwitchCase=\"'geodistance'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-geodistance-filter>\n      <data-model-list-number-filter *ngSwitchCase=\"'number'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-number-filter>\n      <data-model-list-select-filter *ngSwitchCase=\"'select'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-filter>\n      <data-model-list-select-multi-filter *ngSwitchCase=\"'selectmulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-multi-filter>\n      <data-model-list-text-filter *ngSwitchCase=\"'text'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-text-filter>\n      <data-model-list-tree-filter *ngSwitchCase=\"'tree'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-tree-filter>\n    </ng-container>\n  </ng-container>\n</div>" }]
+        }], propDecorators: { list: [{
+                type: Input
+            }], containerClasses: [{
+                type: Input
+            }], itemClasses: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-list-filters.component.js","sourceRoot":"","sources":["../../../../../../../projects/data/src/lib/modellist/model-list-filters/model-list-filters/model-list-filters.component.ts","../../../../../../../projects/data/src/lib/modellist/model-list-filters/model-list-filters/model-list-filters.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAE/C,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAC,4BAA4B,EAAC,MAAM,oEAAoE,CAAC;AAChH,OAAO,EACL,oCAAoC,EACrC,MAAM,oFAAoF,CAAC;AAC5F,OAAO,EACL,yCAAyC,EAC1C,MAAM,gGAAgG,CAAC;AACxG,OAAO,EACL,gCAAgC,EACjC,MAAM,4EAA4E,CAAC;AACpF,OAAO,EACL,qCAAqC,EACtC,MAAM,uFAAuF,CAAC;AAC/F,OAAO,EAAC,6BAA6B,EAAC,MAAM,sEAAsE,CAAC;AACnH,OAAO,EACL,mCAAmC,EACpC,MAAM,kFAAkF,CAAC;AAC1F,OAAO,EAAC,8BAA8B,EAAC,MAAM,wEAAwE,CAAC;AACtH,OAAO,EACL,mCAAmC,EACpC,MAAM,oFAAoF,CAAC;AAC5F,OAAO,EAAC,4BAA4B,EAAC,MAAM,oEAAoE,CAAC;AAChH,OAAO,EAAC,8BAA8B,EAAC,MAAM,wEAAwE,CAAC;AACtH,OAAO,EAAC,4BAA4B,EAAC,MAAM,oEAAoE,CAAC;;;AAEhH,4FAA4F;AAE5F,MAqBa,yBAAyB;IArBtC;QAuBkB,qBAAgB,GAAsB,EAAE,CAAC;QACzC,gBAAW,GAAsB,EAAE,CAAC;KACrD;8GAJY,yBAAyB;kGAAzB,yBAAyB,+KCnDtC,4qEAkBM,yDDkBF,YAAY,2eACZ,4BAA4B,+GAC5B,8BAA8B,iHAC9B,oCAAoC,uHACpC,yCAAyC,0GACzC,gCAAgC,mHAChC,4BAA4B,+GAC5B,qCAAqC,yHACrC,6BAA6B,gHAC7B,mCAAmC,sHACnC,8BAA8B,iHAC9B,mCAAmC,uHACnC,4BAA4B;;SAGnB,yBAAyB;2FAAzB,yBAAyB;kBArBrC,SAAS;+BACE,yBAAyB,cAGvB,IAAI,WACP;wBACP,YAAY;wBACZ,4BAA4B;wBAC5B,8BAA8B;wBAC9B,oCAAoC;wBACpC,yCAAyC;wBACzC,gCAAgC;wBAChC,4BAA4B;wBAC5B,qCAAqC;wBACrC,6BAA6B;wBAC7B,mCAAmC;wBACnC,8BAA8B;wBAC9B,mCAAmC;wBACnC,4BAA4B;qBAC7B;8BAGe,IAAI;sBAAnB,KAAK;gBACU,gBAAgB;sBAA/B,KAAK;gBACU,WAAW;sBAA1B,KAAK","sourcesContent":["import {Component, Input} from '@angular/core';\nimport {ModelList} from '../../model-list.service';\nimport {CommonModule} from '@angular/common';\nimport {ModelListTextFilterComponent} from '../filters/model-list-text-filter/model-list-text-filter.component';\nimport {\n  ModelListAutocompleteFilterComponent\n} from '../filters/model-list-autocomplete-filter/model-list-autocomplete-filter.component';\nimport {\n  ModelListAutocompleteMultiFilterComponent\n} from '../filters/model-list-autocomplete-multi-filter/model-list-autocomplete-multi-filter.component';\nimport {\n  ModelListDatetimeFilterComponent\n} from '../filters/model-list-datetime-filter/model-list-datetime-filter.component';\nimport {\n  ModelListDatetimeRangeFilterComponent\n} from '../filters/model-list-datetimerange-filter/model-list-datetime-range-filter.component';\nimport {ModelListFlagsFilterComponent} from '../filters/model-list-flags-filter/model-list-flags-filter.component';\nimport {\n  ModelListGeodistanceFilterComponent\n} from '../filters/model-list-geodistance-filter/model-list-geodistance-filter.component';\nimport {ModelListSelectFilterComponent} from '../filters/model-list-select-filter/model-list-select-filter.component';\nimport {\n  ModelListSelectMultiFilterComponent\n} from '../filters/model-list-select-multi-filter/model-list-select-multi-filter.component';\nimport {ModelListTreeFilterComponent} from '../filters/model-list-tree-filter/model-list-tree-filter.component';\nimport {ModelListNumberFilterComponent} from '../filters/model-list-number-filter/model-list-number-filter.component';\nimport {ModelListDateFilterComponent} from '../filters/model-list-date-filter/model-list-date-filter.component';\n\n// FIXME: register filter components and load them dynamically to allow user defined filters\n\n@Component({\n  selector: 'data-model-list-filters',\n  templateUrl: './model-list-filters.component.html',\n  styleUrls: ['./model-list-filters.component.sass'],\n  standalone: true,\n  imports: [\n    CommonModule,\n    ModelListTextFilterComponent,\n    ModelListNumberFilterComponent,\n    ModelListAutocompleteFilterComponent,\n    ModelListAutocompleteMultiFilterComponent,\n    ModelListDatetimeFilterComponent,\n    ModelListDateFilterComponent,\n    ModelListDatetimeRangeFilterComponent,\n    ModelListFlagsFilterComponent,\n    ModelListGeodistanceFilterComponent,\n    ModelListSelectFilterComponent,\n    ModelListSelectMultiFilterComponent,\n    ModelListTreeFilterComponent,\n  ],\n})\nexport class ModelListFiltersComponent {\n  @Input() public list!: ModelList<any>;\n  @Input() public containerClasses: string[] | string = '';\n  @Input() public itemClasses: string[] | string = '';\n}\n","\n<div [ngClass]=\"containerClasses\">\n  <ng-container *ngFor=\"let f of list.filters.enabled|async\">\n    <ng-container [ngSwitch]=\"f.type\">\n      <data-model-list-autocomplete-filter *ngSwitchCase=\"'autocomplete'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-filter>\n      <data-model-list-autocomplete-multi-filter *ngSwitchCase=\"'autocompletemulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-autocomplete-multi-filter>\n      <data-model-list-datetime-filter *ngSwitchCase=\"'datetime'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-filter>\n      <data-model-list-date-filter *ngSwitchCase=\"'date'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-date-filter>\n      <data-model-list-datetime-range-filter *ngSwitchCase=\"'datetimerange'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-datetime-range-filter>\n      <data-model-list-flags-filter *ngSwitchCase=\"'flags'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-flags-filter>\n      <data-model-list-geodistance-filter *ngSwitchCase=\"'geodistance'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-geodistance-filter>\n      <data-model-list-number-filter *ngSwitchCase=\"'number'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-number-filter>\n      <data-model-list-select-filter *ngSwitchCase=\"'select'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-filter>\n      <data-model-list-select-multi-filter *ngSwitchCase=\"'selectmulti'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-select-multi-filter>\n      <data-model-list-text-filter *ngSwitchCase=\"'text'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-text-filter>\n      <data-model-list-tree-filter *ngSwitchCase=\"'tree'\" [filter]=\"$any(f)\" [list]=\"list\" [ngClass]=\"itemClasses\"></data-model-list-tree-filter>\n    </ng-container>\n  </ng-container>\n</div>"]}

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

@@ -0,0 +1,31 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ModelListFiltersSelectComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.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\" [title]=\"f.desc\"><i class=\"bi bi-check2-square me-2\"></i><span>{{f.label}}</span></span><span *ngIf=\"!f.enabled\" role=\"button\" [ngClass]=\"itemInactiveClasses\" [title]=\"f.desc\"><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" }] }); }
+}
+export { ModelListFiltersSelectComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.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\" [title]=\"f.desc\"><i class=\"bi bi-check2-square me-2\"></i><span>{{f.label}}</span></span><span *ngIf=\"!f.enabled\" role=\"button\" [ngClass]=\"itemInactiveClasses\" [title]=\"f.desc\"><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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