@recursyve/nice-data-filter-kit 14.1.5 → 14.2.0

package/fesm2020/recursyve-nice-data-filter-kit.mjs

@@ -5,7 +5,7 @@ import * as i5$1 from '@recursyve/nice-ui-kit.v2';
 import { isNullOrUndefined, ObjectUtils, FileUtils, ArrayUtils, ExportBottomSheetComponent, NiceLoadingSpinnerModule, NiceTypeaheadModule, NiceExportBottomSheetModule } from '@recursyve/nice-ui-kit.v2';
 import * as i0 from '@angular/core';
 import { Directive, Input, NgModule, Injectable, Inject, InjectionToken, Optional, Pipe, EventEmitter, Component, ViewEncapsulation, ChangeDetectionStrategy, Output, HostListener, forwardRef, TemplateRef, ContentChild, ContentChildren, ViewChild } from '@angular/core';
-import { Store, StoreConfig, Query, arrayAdd, arrayUpsert, arrayRemove, EntityStore, QueryEntity } from '@datorama/akita';
+import { Store, StoreConfig, Query, arrayAdd, arrayUpsert, arrayRemove, EntityStore, QueryEntity, EntityActions } from '@datorama/akita';
 import { combineLatest, Subject, firstValueFrom, of, tap } from 'rxjs';
 import { __decorate, __metadata } from 'tslib';
 import * as i2 from '@angular/router';
@@ -55,10 +55,11 @@ import * as i1$2 from '@ngx-translate/core';
 import { TranslateModule } from '@ngx-translate/core';
 import * as i18 from '@angular/material/badge';
 import { MatBadgeModule } from '@angular/material/badge';
+import * as i1$4 from '@angular/material/checkbox';
 
 class QueryParamsUtils {
     static hasFilterParameters(params) {
-        const keys = ["start", "length", "order", "fallbackOrder", "search", "rules"];
+        const keys = ["start", "length", "order", "search", "rules"];
         return Object.keys(params).some(key => keys.includes(key));
     }
     static extractFilterParameters(params) {
@@ -77,14 +78,6 @@ class QueryParamsUtils {
                 delete filters.order;
             }
         }
-        if (!isNullOrUndefined(params.fallbackOrder)) {
-            try {
-                filters.fallbackOrder = JSON.parse(params.fallbackOrder);
-            }
-            catch (e) {
-                delete filters.fallbackOrder;
-            }
-        }
         if (!isNullOrUndefined(params.search)) {
             filters.search = params.search;
         }
@@ -112,12 +105,6 @@ class QueryParamsUtils {
         else {
             params.order = null;
         }
-        if (!isNullOrUndefined(filterParameters.fallbackOrder)) {
-            params.fallbackOrder = JSON.stringify(filterParameters.fallbackOrder);
-        }
-        else {
-            params.fallbackOrder = null;
-        }
         if (!isNullOrUndefined(filterParameters.search)) {
             params.search = filterParameters.search;
         }
@@ -2873,6 +2860,20 @@ class NiceFilterViewStore extends EntityStore {
         });
         this.remove(value[idKey]);
     }
+    getParameters(filterParameters) {
+        const { baseRules } = this.getValue();
+        const parameters = {
+            ...filterParameters,
+            rules: filterParameters?.rules ? [...filterParameters.rules] : []
+        };
+        if (baseRules?.length) {
+            parameters.rules.push({
+                condition: "and",
+                rules: baseRules
+            });
+        }
+        return parameters;
+    }
 }
 NiceFilterViewStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewStore, deps: [{ token: FILTER_VIEW_STATE }, { token: FILTER_VIEW_STORE }], target: i0.ɵɵFactoryTarget.Injectable });
 NiceFilterViewStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewStore });
@@ -2903,6 +2904,9 @@ class NiceFilterViewQuery extends QueryEntity {
     selectFilterResult() {
         return this.select("filterResult");
     }
+    getParameters() {
+        return this.store.getParameters(this.store.getValue().filterParameters);
+    }
 }
 NiceFilterViewQuery.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewQuery, deps: [{ token: NiceFilterViewStore }], target: i0.ɵɵFactoryTarget.Injectable });
 NiceFilterViewQuery.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewQuery });
@@ -2975,7 +2979,7 @@ class NiceFilterViewService {
         }
         try {
             this.store.setLoading(true);
-            const result = await firstValueFrom(this.filterService.filter(this.getParameters(filterParameters)));
+            const result = await firstValueFrom(this.filterService.filter(this.store.getParameters(filterParameters)));
             this.store.setResult(result);
         }
         catch (e) {
@@ -2992,7 +2996,7 @@ class NiceFilterViewService {
         }
         try {
             this.store.setLoading(true);
-            const result = await firstValueFrom(this.filterService.getFile(type, this.getParameters(filterParameters)));
+            const result = await firstValueFrom(this.filterService.getFile(type, this.store.getParameters(filterParameters)));
             FileUtils.downloadFile(`${downloadFileName}.${type}`, result);
         }
         catch (e) {
@@ -3009,7 +3013,7 @@ class NiceFilterViewService {
         }
         try {
             this.store.setLoading(true);
-            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.getParameters(filterParameters)));
+            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.store.getParameters(filterParameters)));
             FileUtils.openPrintableWindow(result);
         }
         catch (e) {
@@ -3124,20 +3128,6 @@ class NiceFilterViewService {
             });
         }
     }
-    getParameters(filterParameters) {
-        const { baseRules } = this.store.getValue();
-        const parameters = {
-            ...filterParameters,
-            rules: filterParameters?.rules ? [...filterParameters.rules] : []
-        };
-        if (baseRules?.length) {
-            parameters.rules.push({
-                condition: "and",
-                rules: baseRules
-            });
-        }
-        return parameters;
-    }
 }
 NiceFilterViewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewService, deps: [{ token: NiceFilterViewStore }, { token: NiceFilterService }], target: i0.ɵɵFactoryTarget.Injectable });
 NiceFilterViewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewService });
@@ -3245,7 +3235,7 @@ class NiceFilterInfiniteScrollDataViewComponent {
     constructor(query, service) {
         this.query = query;
         this.service = service;
-        this.data$ = this.query.selectAll().pipe(tap(x => console.log(x)));
+        this.data$ = this.query.selectAll();
     }
     async loadNextPage() {
         const { filterParameters } = this.query.getValue();
@@ -3332,7 +3322,7 @@ class NiceFilterMatPaginatorPaginationDirective {
             const { filterParameters } = this.query.getValue();
             this.service.setParameters({
                 ...filterParameters,
-                start: page.pageIndex,
+                start: page.pageIndex * page.pageSize,
                 length: page.pageSize
             }, true);
         });
@@ -3717,6 +3707,450 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImpor
                 }]
         }] });
 
+class NicePreloadSelectedEntitiesProvider {
+}
+NicePreloadSelectedEntitiesProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NicePreloadSelectedEntitiesProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NicePreloadSelectedEntitiesProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NicePreloadSelectedEntitiesProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NicePreloadSelectedEntitiesProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER = new InjectionToken("nice_preload_selected_entities_provider");
+
+class SelectableListStateService {
+    constructor(store, preloadService, options) {
+        this.store = store;
+        this.preloadService = preloadService;
+        this.options = options;
+    }
+    get idKey() {
+        return this.options?.idKey ?? "id";
+    }
+    get preloadedWindow() {
+        return this.options?.preloadWindow ?? 2;
+    }
+    setActive(entity) {
+        this.store.setActive(entity[this.idKey]);
+    }
+    getIndex(identifier) {
+        const { ids } = this.store.getValue();
+        const index = ids.indexOf(identifier);
+        return index + 1;
+    }
+    async selectAll(options) {
+        if (!this.preloadService) {
+            return this.store.update({
+                allSelected: true
+            });
+        }
+        const ids = await this.preloadService.loadAllEntities(options);
+        this.store.set(ids.map((id) => ({
+            [this.idKey]: id,
+            loaded: false
+        })));
+        return this.store.update({
+            allSelected: true
+        });
+    }
+    async select(id) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayRemove(state.unselectedEntity, id)
+        }));
+        if (!this.preloadService) {
+            this.store.add({
+                [this.idKey]: id,
+                loaded: false
+            });
+        }
+        const entity = await this.preloadService.loadEntityById(id);
+        return this.store.add({
+            ...entity,
+            loaded: true
+        });
+    }
+    async selectEntity(entity) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayRemove(state.unselectedEntity, entity[this.idKey])
+        }));
+        if (!this.preloadService) {
+            return this.store.upsert(entity[this.idKey], { ...entity, loaded: true });
+        }
+        const preloadedEntity = await this.preloadService.reloadEntity(entity);
+        return this.store.upsert(preloadedEntity[this.idKey], { ...preloadedEntity, loaded: true });
+    }
+    async selectManyEntities(entities) {
+        if (!this.preloadService) {
+            return this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));
+        }
+        const preloadedEntities = await this.preloadService.reloadEntities(entities);
+        return this.store.upsertMany(preloadedEntities.map((preloadedEntity) => ({ ...preloadedEntity, loaded: true })));
+    }
+    unselectAll() {
+        this.store.set([]);
+        return this.store.update({
+            allSelected: false,
+            unselectedEntity: []
+        });
+    }
+    unselect(id) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayAdd(state.unselectedEntity, id)
+        }));
+        this.store.remove(id);
+    }
+    unselectEntity(entity) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayAdd(state.unselectedEntity, entity[this.idKey])
+        }));
+        this.store.remove(entity[this.idKey]);
+    }
+    unselectManyEntities(entities) {
+        this.store.remove(entities.map((entity) => entity[this.idKey]));
+    }
+    async setEntities(ids, activeId) {
+        this.store.update({
+            unselectedEntity: [],
+            allSelected: false
+        });
+        this.store.set(ids.map((id) => ({
+            [this.idKey]: id,
+            loaded: false
+        })));
+        if (activeId) {
+            this.store.setActive(activeId);
+        }
+    }
+    async next() {
+        const { ids, active } = this.store.getValue();
+        const index = ids.indexOf(active);
+        await this.loadActiveEntity(ids[index + 1], 1);
+    }
+    async previous() {
+        const { ids, active } = this.store.getValue();
+        const index = ids.indexOf(active);
+        await this.loadActiveEntity(ids[index - 1], -1);
+    }
+    async first() {
+        const { ids } = this.store.getValue();
+        await this.loadActiveEntity(ids[0], 1);
+    }
+    async last() {
+        const { ids } = this.store.getValue();
+        await this.loadActiveEntity(ids[ids.length - 1], -1);
+    }
+    async removeActive() {
+        const { active, ids } = this.store.getValue();
+        const index = ids.indexOf(active);
+        this.store.remove(active);
+        if (index === (ids.length - 1)) {
+            await this.loadActiveEntity(ids[index - 1], -1);
+        }
+        else {
+            await this.loadActiveEntity(ids[index + 1], 1);
+        }
+    }
+    async loadActiveEntity(id, direction) {
+        try {
+            this.store.setActive(id);
+            const { entities } = this.store.getValue();
+            if (!entities[+id + direction * this.preloadedWindow]?.loaded) {
+                await this.loadEntities(false);
+            }
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+    }
+    async loadEntities(loadExtremity) {
+        if (!this.preloadService) {
+            return;
+        }
+        const toLoad = this.getListIdToLoad(loadExtremity);
+        if (!toLoad.length) {
+            return;
+        }
+        const entities = await this.preloadService.loadEntitiesById(toLoad);
+        this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));
+    }
+    getListIdToLoad(loadExtremity) {
+        const { active, ids, entities } = this.store.getValue();
+        const from = ids.indexOf(active) - this.preloadedWindow > 0 ? ids.indexOf(active) - this.preloadedWindow : 0;
+        const to = ids.indexOf(active) + this.preloadedWindow < ids.length - 1
+            ? ids.indexOf(active) + this.preloadedWindow
+            : ids.length - 1;
+        const toLoad = [];
+        if (loadExtremity) {
+            if (ids.length <= 2) {
+                return ids;
+            }
+            toLoad.push(ids[0], ids[ids.length - 1]);
+        }
+        for (let i = from; i <= to; i++) {
+            if (ids[i] === null || ids[0] === undefined) {
+                continue;
+            }
+            if (!toLoad.includes(ids[i]) && !entities[ids[i]]?.loaded) {
+                toLoad.push(ids[i]);
+            }
+        }
+        return toLoad;
+    }
+}
+
+class SelectableListService {
+    constructor(providers) {
+        this.providers = providers;
+        this.stores = new Map();
+    }
+    createState(name, options) {
+        const store = new EntityStore({ allSelected: false, unselectedEntity: [] }, { name, idKey: options?.idKey });
+        const query = new QueryEntity(store);
+        const state = { store, query };
+        this.stores.set(name, state);
+        return state;
+    }
+    getState(name) {
+        return this.stores.get(name);
+    }
+    withState(stateName, options) {
+        const provider = this.providers?.find((p) => p.state === stateName);
+        const state = this.getState(stateName);
+        if (state) {
+            return new SelectableListStateService(state.store, provider, options);
+        }
+        const newState = this.createState(stateName, options);
+        return new SelectableListStateService(newState.store, provider, options);
+    }
+    query(stateName) {
+        const state = this.getState(stateName);
+        if (!state) {
+            throw new Error("No state found");
+        }
+        return state.query;
+    }
+}
+SelectableListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, deps: [{ token: NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectableListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER]
+                }] }]; } });
+
+// tslint:disable-next-line:directive-class-suffix
+class NiceSelectableListDirective {
+    constructor() {
+        this.defaultOptions = { idKey: "id", preloadWindow: 2 };
+    }
+    ngOnInit() {
+        if (!this.options) {
+            this.options = { ...this.defaultOptions };
+        }
+    }
+    ngOnChanges(changes) {
+        if ("options" in changes) {
+            this.options = {
+                ...this.defaultOptions,
+                ...changes.options.currentValue
+            };
+        }
+    }
+}
+NiceSelectableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NiceSelectableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.3", type: NiceSelectableListDirective, selector: "[niceSelectableList]", inputs: { state: "state", options: "options" }, queries: [{ propertyName: "checkboxes", predicate: NiceSelectableListCheckboxDirective, descendants: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[niceSelectableList]"
+                }]
+        }], propDecorators: { state: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], checkboxes: [{
+                type: ContentChildren,
+                args: [NiceSelectableListCheckboxDirective, { descendants: true }]
+            }] } });
+
+// tslint:disable-next-line:directive-class-suffix
+class NiceSelectableListCheckboxDirective {
+    constructor(checkbox, selectableList, selectableListService) {
+        this.checkbox = checkbox;
+        this.selectableList = selectableList;
+        this.selectableListService = selectableListService;
+        this.unsubscribeAll$ = new Subject();
+    }
+    get currentId() {
+        if (!this.selectableEntity || !this.selectableListStateService) {
+            return null;
+        }
+        return this.selectableEntity[this.selectableListStateService.idKey];
+    }
+    ngOnInit() {
+        this.selectableListStateService = this.selectableListService.withState(this.selectableList.state);
+        this.selectableListStateQuery = this.selectableListService.query(this.selectableList.state);
+        if (this.selectableEntity) {
+            this.handleSelectableEntity();
+        }
+        if (this.selectPage) {
+            this.handleSelectPage();
+        }
+    }
+    ngOnDestroy() {
+        this.unsubscribeAll$.next();
+        this.unsubscribeAll$.complete();
+    }
+    handleSelectableEntity() {
+        if (this.checkbox.checked) {
+            this.selectableListStateService.selectEntity(this.selectableEntity);
+        }
+        if (!this.checkbox.checked && this.selectableListStateQuery.getEntity(this.currentId)) {
+            this.checkbox.checked = true;
+        }
+        this.checkbox.change.pipe(takeUntil(this.unsubscribeAll$)).subscribe((value) => {
+            if (value.checked && !this.selectableListStateQuery.getEntity(this.currentId)) {
+                this.selectableListStateService.selectEntity(this.selectableEntity);
+            }
+            if (!value.checked && this.selectableListStateQuery.getEntity(this.currentId)) {
+                this.selectableListStateService.unselectEntity(this.selectableEntity);
+            }
+        });
+        this.selectableListStateQuery.selectEntityAction([
+            EntityActions.Add,
+            EntityActions.Remove,
+            EntityActions.Set
+        ]).pipe(takeUntil(this.unsubscribeAll$)).subscribe(({ ids, type }) => {
+            const shouldTakeAction = ids.includes(this.currentId);
+            if (!shouldTakeAction) {
+                if (type === EntityActions.Set) {
+                    this.checkbox.checked = false;
+                }
+                return;
+            }
+            if (!this.checkbox.checked && (type === EntityActions.Add || type === EntityActions.Set)) {
+                this.checkbox.checked = true;
+            }
+            if (this.checkbox.checked && type === EntityActions.Remove) {
+                this.checkbox.checked = false;
+            }
+        });
+    }
+    handleSelectPage() {
+        this.selectableListStateQuery.selectCount().subscribe(() => this.updateCheckboxState());
+        this.selectableList.checkboxes.changes.pipe(takeUntil(this.unsubscribeAll$)).subscribe(() => this.updateCheckboxState());
+        this.checkbox.change.pipe(takeUntil(this.unsubscribeAll$)).subscribe((value) => {
+            for (const checkbox of this.selectableList.checkboxes) {
+                if (checkbox.selectPage) {
+                    continue;
+                }
+                checkbox.checkbox.checked = value.checked;
+                checkbox.checkbox.change.emit({ checked: value.checked, source: checkbox.checkbox });
+            }
+        });
+    }
+    updateCheckboxState() {
+        const checkboxes = this.selectableList.checkboxes.filter((checkbox) => !checkbox.selectPage);
+        if (!checkboxes.length) {
+            return;
+        }
+        const count = this.selectableListStateQuery.getCount();
+        if (!count) {
+            this.checkbox.indeterminate = false;
+            this.checkbox.checked = false;
+            return;
+        }
+        if (count !== checkboxes.length) {
+            this.checkbox.indeterminate = true;
+            this.checkbox.checked = false;
+            return;
+        }
+        if (count === checkboxes.length) {
+            this.checkbox.checked = true;
+            this.checkbox.indeterminate = false;
+        }
+    }
+}
+NiceSelectableListCheckboxDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListCheckboxDirective, deps: [{ token: i1$4.MatCheckbox }, { token: NiceSelectableListDirective }, { token: SelectableListService }], target: i0.ɵɵFactoryTarget.Directive });
+NiceSelectableListCheckboxDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.3", type: NiceSelectableListCheckboxDirective, selector: "mat-checkbox[niceSelectableListCheckbox]", inputs: { selectableEntity: "selectableEntity", selectPage: "selectPage" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListCheckboxDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "mat-checkbox[niceSelectableListCheckbox]"
+                }]
+        }], ctorParameters: function () { return [{ type: i1$4.MatCheckbox }, { type: NiceSelectableListDirective }, { type: SelectableListService }]; }, propDecorators: { selectableEntity: [{
+                type: Input
+            }], selectPage: [{
+                type: Input
+            }] } });
+
+// tslint:disable-next-line:directive-class-suffix
+class NiceSelectableListSelectAllDirective {
+    constructor(niceFilterViewQuery, selectableList, selectableListService) {
+        this.niceFilterViewQuery = niceFilterViewQuery;
+        this.selectableList = selectableList;
+        this.selectableListService = selectableListService;
+        this.action = "select";
+    }
+    ngOnInit() {
+        this.selectableListStateService = this.selectableListService.withState(this.selectableList.state);
+        this.selectableListStateQuery = this.selectableListService.query(this.selectableList.state);
+    }
+    onClick() {
+        if (this.action === "select") {
+            const filterParameters = this.niceFilterViewQuery?.getParameters() ?? {};
+            const query = filterParameters ? FilterUtils.parametersToRequest(filterParameters) : null;
+            this.selectableListStateService.selectAll({ query });
+        }
+        else {
+            this.selectableListStateService.unselectAll();
+        }
+    }
+}
+NiceSelectableListSelectAllDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListSelectAllDirective, deps: [{ token: NiceFilterViewQuery, optional: true }, { token: NiceSelectableListDirective }, { token: SelectableListService }], target: i0.ɵɵFactoryTarget.Directive });
+NiceSelectableListSelectAllDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.3", type: NiceSelectableListSelectAllDirective, selector: "button[niceSelectableListSelectAll]", inputs: { action: "action" }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListSelectAllDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "button[niceSelectableListSelectAll]"
+                }]
+        }], ctorParameters: function () { return [{ type: NiceFilterViewQuery, decorators: [{
+                    type: Optional
+                }] }, { type: NiceSelectableListDirective }, { type: SelectableListService }]; }, propDecorators: { action: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+
+class NiceSelectableListModule {
+    static register(...providers) {
+        return {
+            ngModule: NiceSelectableListModule,
+            providers: providers.map(x => ({
+                provide: NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER,
+                useClass: x,
+                multi: true
+            }))
+        };
+    }
+}
+NiceSelectableListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NiceSelectableListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, declarations: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective], exports: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective] });
+NiceSelectableListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, providers: [SelectableListService] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective],
+                    providers: [SelectableListService],
+                    exports: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective]
+                }]
+        }] });
+
 class StringUtils {
 }
 // tslint:disable-next-line:max-line-length
@@ -3733,5 +4167,5 @@ String.prototype.toTableColumn = function (sortableOrOptions, nullLast) {
  * Generated bundle index. Do not edit.
  */
 
-export { DateFilterComponent, FilterComponent, FilterGroupIconPipe, FilterOperatorTypes, FilterSelectionComponent, FilterType, FilterUtils, LayoutContent, NiceBaseFilterViewComponent, NiceBaseListButtonsDirective, NiceBaseListCardsDirective, NiceBaseListComponent, NiceBaseListCustomContentDirective, NiceBaseListDirectiveModule, NiceBaseListEmptySearchResultStateDirective, NiceBaseListEmptyStateDirective, NiceBaseListFiltersDirective, NiceBaseListModule, NiceBaseListQuery, NiceBaseListService, NiceBaseListStore, NiceBaseListTableDirective, NiceBaseListTitleDirective, NiceCustomDateAdapter, NiceFilterApi, NiceFilterCustomDataViewComponent, NiceFilterDataDirective, NiceFilterExportButtonsComponent, NiceFilterExportDirective, NiceFilterGroupService, NiceFilterInfiniteScrollDataViewComponent, NiceFilterMatPaginatorPaginationDirective, NiceFilterMatSortSortingDirective, NiceFilterMatTableViewDirective, NiceFilterQueryParamsDirective, NiceFilterSearchComponent, NiceFilterService, NiceFilterViewComponent, NiceFilterViewModule, NiceFilterViewQuery, NiceFilterViewService, NiceListState, NiceMultiStateFilterService, NiceMultiStateListComponent, NiceMultiStateListModule, NiceMultiStateListQuery, NiceMultiStateListService, NiceMultiStateListStore, NiceQueryBuilderComponent, NiceQueryBuilderModule, NiceSavedReportService, NumberFilterComponent, OrderUtils, QBFilterUtils, QueryBuilderTriggerDirective, RadioFilterComponent, RuleComponent, SelectFilterComponent, StringUtils, TableColumns, TextFilterComponent, defaultLayout, initialBaseListState, initialValue$1 as initialValue, mixinNiceFilterApi };
+export { DateFilterComponent, FilterComponent, FilterGroupIconPipe, FilterOperatorTypes, FilterSelectionComponent, FilterType, FilterUtils, LayoutContent, NiceBaseFilterViewComponent, NiceBaseListButtonsDirective, NiceBaseListCardsDirective, NiceBaseListComponent, NiceBaseListCustomContentDirective, NiceBaseListDirectiveModule, NiceBaseListEmptySearchResultStateDirective, NiceBaseListEmptyStateDirective, NiceBaseListFiltersDirective, NiceBaseListModule, NiceBaseListQuery, NiceBaseListService, NiceBaseListStore, NiceBaseListTableDirective, NiceBaseListTitleDirective, NiceCustomDateAdapter, NiceFilterApi, NiceFilterCustomDataViewComponent, NiceFilterDataDirective, NiceFilterExportButtonsComponent, NiceFilterExportDirective, NiceFilterGroupService, NiceFilterInfiniteScrollDataViewComponent, NiceFilterMatPaginatorPaginationDirective, NiceFilterMatSortSortingDirective, NiceFilterMatTableViewDirective, NiceFilterQueryParamsDirective, NiceFilterSearchComponent, NiceFilterService, NiceFilterViewComponent, NiceFilterViewModule, NiceFilterViewQuery, NiceFilterViewService, NiceListState, NiceMultiStateFilterService, NiceMultiStateListComponent, NiceMultiStateListModule, NiceMultiStateListQuery, NiceMultiStateListService, NiceMultiStateListStore, NicePreloadSelectedEntitiesProvider, NiceQueryBuilderComponent, NiceQueryBuilderModule, NiceSavedReportService, NiceSelectableListCheckboxDirective, NiceSelectableListDirective, NiceSelectableListModule, NiceSelectableListSelectAllDirective, NumberFilterComponent, OrderUtils, QBFilterUtils, QueryBuilderTriggerDirective, RadioFilterComponent, RuleComponent, SelectFilterComponent, SelectableListService, SelectableListStateService, StringUtils, TableColumns, TextFilterComponent, defaultLayout, initialBaseListState, initialValue$1 as initialValue, mixinNiceFilterApi };
 //# sourceMappingURL=recursyve-nice-data-filter-kit.mjs.map