@recursyve/nice-data-filter-kit 14.0.6 → 14.1.0

package/esm2020/lib/components/nice-filter-view/directives/query-params.directive.mjs

@@ -0,0 +1,81 @@
+import { Directive, EventEmitter, Output } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+import { Subject } from "rxjs";
+import { map, takeUntil } from "rxjs/operators";
+import { FilterUtils } from "../../../utils/filter.utils";
+import { QueryParamsUtils } from "../../../utils/query-params.utils";
+import { NiceFilterViewQuery } from "../store/nice-filter-view.query";
+import { NiceFilterViewService } from "../store/nice-filter-view.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../store/nice-filter-view.query";
+import * as i2 from "../store/nice-filter-view.service";
+import * as i3 from "@angular/router";
+export class NiceFilterQueryParamsDirective {
+    constructor(query, service, route, router) {
+        this.query = query;
+        this.service = service;
+        this.route = route;
+        this.router = router;
+        this.init = new EventEmitter();
+        this.unsubscribeAll$ = new Subject();
+        this.initialized = false;
+    }
+    ngOnInit() {
+        this.query.selectFilterParameters().pipe(takeUntil(this.unsubscribeAll$)).subscribe((parameters) => {
+            this.updateQueryParams(parameters);
+        });
+        this.loadQueryParams();
+    }
+    ngOnDestroy() {
+        this.unsubscribeAll$.next();
+        this.unsubscribeAll$.complete();
+    }
+    updateQueryParams(parameters) {
+        if (!this.route) {
+            return;
+        }
+        const params = { ...parameters };
+        const { mode } = this.query.getValue();
+        if (mode === "accumulated") {
+            delete params.start;
+            delete params.length;
+        }
+        this.router.navigate([], {
+            relativeTo: this.route,
+            queryParams: QueryParamsUtils.filterParametersToParamsMap(params),
+            queryParamsHandling: "merge"
+        });
+    }
+    loadQueryParams() {
+        this.route.queryParams
+            .pipe(takeUntil(this.unsubscribeAll$), map((params) => {
+            return {
+                params: QueryParamsUtils.extractFilterParameters(params)
+            };
+        }))
+            .subscribe(({ params }) => {
+            if (!QueryParamsUtils.hasFilterParameters(params) || Object.keys(params).length === 0) {
+                params = { ...this.query.getValue().filterParameters };
+            }
+            const { filterParameters, filterResult } = this.query.getValue();
+            if (FilterUtils.filterChangeNeedsRefresh(filterParameters, params) ||
+                !filterResult) {
+                this.service.setParameters(params, false);
+            }
+            if (!this.initialized) {
+                this.initialized = true;
+                this.init.emit();
+                this.service.filter();
+            }
+        });
+    }
+}
+NiceFilterQueryParamsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterQueryParamsDirective, deps: [{ token: i1.NiceFilterViewQuery }, { token: i2.NiceFilterViewService }, { token: i3.ActivatedRoute }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Directive });
+NiceFilterQueryParamsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.3", type: NiceFilterQueryParamsDirective, selector: "nice-filter-view[niceFilterQueryParams]", outputs: { init: "init" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterQueryParamsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: "nice-filter-view[niceFilterQueryParams]" }]
+        }], ctorParameters: function () { return [{ type: i1.NiceFilterViewQuery }, { type: i2.NiceFilterViewService }, { type: i3.ActivatedRoute }, { type: i3.Router }]; }, propDecorators: { init: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/nice-filter-view/nice-base-filter-view.component.mjs

@@ -0,0 +1,89 @@
+import { Component, ViewChild } from "@angular/core";
+import { NiceFilterViewComponent } from "./nice-filter-view.component";
+import { NiceFilterViewQuery } from "./store/nice-filter-view.query";
+import { NiceFilterViewService } from "./store/nice-filter-view.service";
+import * as i0 from "@angular/core";
+export class NiceBaseFilterViewComponent {
+    ngOnInit(autoLoad = true, { mode, loadConfig, configQueryParams } = {}) {
+        if (mode) {
+            this.filterViewService.setMode(mode);
+        }
+        const { autoLoad: defaultAutoLoad } = this.filterViewQuery.getValue();
+        if (autoLoad && defaultAutoLoad) {
+            this.filterViewService.filter();
+        }
+        else {
+            this.filterViewService.setAutoLoad(autoLoad);
+        }
+        if (loadConfig) {
+            this.filterViewService.loadConfig(configQueryParams);
+        }
+        this.filterViewLoading$ = this.filterViewQuery.selectLoading();
+    }
+    /**
+     * Call the filter endpoint with the current filter parameters.
+     */
+    loadData() {
+        this.filterViewService.filter();
+    }
+    /**
+     * Disable the filter view. This will stop calling any api routes.
+     */
+    disable() {
+        this.filterViewService.disable();
+    }
+    /**
+     * Enable the filter view. This will resume calling any api routes.
+     */
+    enable() {
+        this.filterViewService.enable();
+    }
+    /**
+     * Update the loading state
+     */
+    setLoading(loading) {
+        this.filterViewService.setLoading(loading);
+    }
+    /**
+     * Set a set of rules that won't be saved in the current filterParameters config.
+     * NOTE: These rules will be injected in each filter request.
+     */
+    setBaseRules(rule, reload = true) {
+        this.filterViewService.setBaseRules(rule, reload);
+    }
+    /**
+     * Reset all rules with a new set of rules.
+     */
+    setRules(rules, reload = true) {
+        this.filterViewService.setRules(rules, reload);
+    }
+    /**
+     * Add or update a rule.
+     * NOTE: This will only check for rules in the first element of the rules array in the current filterParameters.
+     */
+    upsertRule(id, newRule, reload = true) {
+        this.filterViewService.upsertRule(id, newRule, reload);
+    }
+    /**
+     * Remove a rule.
+     * NOTE: This will only check for rules in the first element of the rules array in the current filterParameters.
+     */
+    removeRule(id, reload = true) {
+        this.filterViewService.removeRule(id, reload);
+    }
+}
+NiceBaseFilterViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceBaseFilterViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NiceBaseFilterViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.3", type: NiceBaseFilterViewComponent, selector: "ng-component", viewQueries: [{ propertyName: "filterViewService", first: true, predicate: NiceFilterViewComponent, descendants: true, read: NiceFilterViewService, static: true }, { propertyName: "filterViewQuery", first: true, predicate: NiceFilterViewComponent, descendants: true, read: NiceFilterViewQuery, static: true }], ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceBaseFilterViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``
+                }]
+        }], propDecorators: { filterViewService: [{
+                type: ViewChild,
+                args: [NiceFilterViewComponent, { read: NiceFilterViewService, static: true }]
+            }], filterViewQuery: [{
+                type: ViewChild,
+                args: [NiceFilterViewComponent, { read: NiceFilterViewQuery, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/nice-filter-view/nice-filter-view.component.mjs

@@ -0,0 +1,34 @@
+import { Component, Input, ViewEncapsulation } from "@angular/core";
+import { NiceFilterViewQuery } from "./store/nice-filter-view.query";
+import { NiceFilterViewService } from "./store/nice-filter-view.service";
+import { NiceFilterViewStore } from "./store/nice-filter-view.store";
+import * as i0 from "@angular/core";
+import * as i1 from "./store/nice-filter-view.service";
+export class NiceFilterViewComponent {
+    constructor(service) {
+        this.service = service;
+        this.queryParams = {};
+    }
+    ngOnChanges(changes) {
+        if ("queryParams" in changes) {
+            this.service.setQueryParams(this.queryParams);
+        }
+    }
+}
+NiceFilterViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewComponent, deps: [{ token: i1.NiceFilterViewService }], target: i0.ɵɵFactoryTarget.Component });
+NiceFilterViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.3", type: NiceFilterViewComponent, selector: "nice-filter-view", inputs: { queryParams: "queryParams" }, providers: [
+        NiceFilterViewQuery,
+        NiceFilterViewService,
+        NiceFilterViewStore
+    ], usesOnChanges: true, ngImport: i0, template: "<ng-content></ng-content>\n", styles: [""], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "nice-filter-view", encapsulation: ViewEncapsulation.None, providers: [
+                        NiceFilterViewQuery,
+                        NiceFilterViewService,
+                        NiceFilterViewStore
+                    ], template: "<ng-content></ng-content>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.NiceFilterViewService }]; }, propDecorators: { queryParams: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/nice-filter-view/nice-filter-view.constant.mjs

@@ -0,0 +1,5 @@
+import { InjectionToken } from "@angular/core";
+export const EXPORTS_SETTINGS = new InjectionToken("exports_settings");
+export const FILTER_VIEW_ICONS = new InjectionToken("filter_view_icons");
+export const FILTER_VIEW_STATE = new InjectionToken("filter_view_state");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmljZS1maWx0ZXItdmlldy5jb25zdGFudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pY2UtZGF0YS1maWx0ZXIta2l0L3NyYy9saWIvY29tcG9uZW50cy9uaWNlLWZpbHRlci12aWV3L25pY2UtZmlsdGVyLXZpZXcuY29uc3RhbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3ZFLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLElBQUksY0FBYyxDQUFDLG1CQUFtQixDQUFDLENBQUM7QUFDekUsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxjQUFjLENBQUMsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuZXhwb3J0IGNvbnN0IEVYUE9SVFNfU0VUVElOR1MgPSBuZXcgSW5qZWN0aW9uVG9rZW4oXCJleHBvcnRzX3NldHRpbmdzXCIpO1xuZXhwb3J0IGNvbnN0IEZJTFRFUl9WSUVXX0lDT05TID0gbmV3IEluamVjdGlvblRva2VuKFwiZmlsdGVyX3ZpZXdfaWNvbnNcIik7XG5leHBvcnQgY29uc3QgRklMVEVSX1ZJRVdfU1RBVEUgPSBuZXcgSW5qZWN0aW9uVG9rZW4oXCJmaWx0ZXJfdmlld19zdGF0ZVwiKTtcbiJdfQ==

package/esm2020/lib/components/nice-filter-view/nice-filter-view.module.mjs

@@ -0,0 +1,143 @@
+import { AsyncPipe, NgIf, NgTemplateOutlet } from "@angular/common";
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { MatBottomSheetModule } from "@angular/material/bottom-sheet";
+import { MatButtonModule } from "@angular/material/button";
+import { MatIconModule } from "@angular/material/icon";
+import { MatTooltipModule } from "@angular/material/tooltip";
+import { TranslateModule } from "@ngx-translate/core";
+import { NiceExportBottomSheetModule } from "@recursyve/nice-ui-kit.v2";
+import { defaultIcons } from "../base-list/models/icons.model";
+import { NiceFilterService } from "../base-list/providers/base-filter.service";
+import { NiceFilterDataDirective } from "./components/common/data.directive";
+import { NiceFilterCustomDataViewComponent } from "./components/custom-data-view/custom-data-view.component";
+import { NiceFilterExportButtonsComponent } from "./components/export-buttons/export-buttons.component";
+import { NiceFilterExportDirective } from "./components/export-buttons/export.directive";
+import { NiceFilterInfiniteScrollDataViewComponent } from "./components/infinite-scroll-data-view/infinite-scroll-data-view.component";
+import { NiceFilterSearchComponent } from "./components/search/search.component";
+import { NiceFilterMatPaginatorPaginationDirective } from "./directives/mat-paginator";
+import { NiceFilterMatSortSortingDirective } from "./directives/mat-sort";
+import { NiceFilterMatTableViewDirective } from "./directives/mat-tables";
+import { NiceFilterQueryParamsDirective } from "./directives/query-params.directive";
+import { NiceFilterViewComponent } from "./nice-filter-view.component";
+import { EXPORTS_SETTINGS, FILTER_VIEW_ICONS, FILTER_VIEW_STATE } from "./nice-filter-view.constant";
+import * as i0 from "@angular/core";
+export class NiceFilterViewModule {
+    static forRoot(options) {
+        return {
+            ngModule: NiceFilterViewModule,
+            providers: [
+                {
+                    provide: FILTER_VIEW_ICONS,
+                    useValue: {
+                        ...defaultIcons,
+                        ...(options?.icons ?? {})
+                    }
+                }
+            ].filter(x => !!x)
+        };
+    }
+    static providerFactory(options) {
+        return [
+            {
+                provide: NiceFilterService,
+                useClass: options.filterService
+            },
+            {
+                provide: EXPORTS_SETTINGS,
+                useValue: options.exports ?? {
+                    pdf: true,
+                    xlsx: true,
+                    csv: true
+                }
+            },
+            {
+                provide: FILTER_VIEW_STATE,
+                useValue: options.state ?? {}
+            }
+        ].filter(x => !!x);
+    }
+}
+NiceFilterViewModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NiceFilterViewModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewModule, declarations: [NiceFilterViewComponent,
+        NiceFilterCustomDataViewComponent,
+        NiceFilterExportButtonsComponent,
+        NiceFilterInfiniteScrollDataViewComponent,
+        NiceFilterSearchComponent,
+        NiceFilterDataDirective,
+        NiceFilterExportDirective,
+        NiceFilterMatTableViewDirective,
+        NiceFilterMatSortSortingDirective,
+        NiceFilterMatPaginatorPaginationDirective,
+        NiceFilterQueryParamsDirective], imports: [TranslateModule,
+        MatIconModule,
+        FormsModule,
+        AsyncPipe,
+        NgIf,
+        NgTemplateOutlet,
+        MatTooltipModule,
+        MatButtonModule,
+        MatBottomSheetModule,
+        NiceExportBottomSheetModule], exports: [NiceFilterViewComponent,
+        NiceFilterCustomDataViewComponent,
+        NiceFilterExportButtonsComponent,
+        NiceFilterInfiniteScrollDataViewComponent,
+        NiceFilterSearchComponent,
+        NiceFilterDataDirective,
+        NiceFilterExportDirective,
+        NiceFilterMatTableViewDirective,
+        NiceFilterMatSortSortingDirective,
+        NiceFilterMatPaginatorPaginationDirective,
+        NiceFilterQueryParamsDirective] });
+NiceFilterViewModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewModule, imports: [TranslateModule,
+        MatIconModule,
+        FormsModule,
+        MatTooltipModule,
+        MatButtonModule,
+        MatBottomSheetModule,
+        NiceExportBottomSheetModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        TranslateModule,
+                        MatIconModule,
+                        FormsModule,
+                        AsyncPipe,
+                        NgIf,
+                        NgTemplateOutlet,
+                        MatTooltipModule,
+                        MatButtonModule,
+                        MatBottomSheetModule,
+                        NiceExportBottomSheetModule
+                    ],
+                    declarations: [
+                        NiceFilterViewComponent,
+                        NiceFilterCustomDataViewComponent,
+                        NiceFilterExportButtonsComponent,
+                        NiceFilterInfiniteScrollDataViewComponent,
+                        NiceFilterSearchComponent,
+                        NiceFilterDataDirective,
+                        NiceFilterExportDirective,
+                        NiceFilterMatTableViewDirective,
+                        NiceFilterMatSortSortingDirective,
+                        NiceFilterMatPaginatorPaginationDirective,
+                        NiceFilterQueryParamsDirective
+                    ],
+                    providers: [],
+                    exports: [
+                        NiceFilterViewComponent,
+                        NiceFilterCustomDataViewComponent,
+                        NiceFilterExportButtonsComponent,
+                        NiceFilterInfiniteScrollDataViewComponent,
+                        NiceFilterSearchComponent,
+                        NiceFilterDataDirective,
+                        NiceFilterExportDirective,
+                        NiceFilterMatTableViewDirective,
+                        NiceFilterMatSortSortingDirective,
+                        NiceFilterMatPaginatorPaginationDirective,
+                        NiceFilterQueryParamsDirective
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nice-filter-view.module.js","sourceRoot":"","sources":["../../../../../../projects/nice-data-filter-kit/src/lib/components/nice-filter-view/nice-filter-view.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgIf, NgTemplateOutlet } from \"@angular/common\";\nimport { ModuleWithProviders, NgModule, Provider, Type } from \"@angular/core\";\nimport { FormsModule } from \"@angular/forms\";\nimport { MatBottomSheetModule } from \"@angular/material/bottom-sheet\";\nimport { MatButtonModule } from \"@angular/material/button\";\nimport { MatIconModule } from \"@angular/material/icon\";\nimport { MatTooltipModule } from \"@angular/material/tooltip\";\nimport { TranslateModule } from \"@ngx-translate/core\";\nimport { NiceExportBottomSheetModule } from \"@recursyve/nice-ui-kit.v2\";\nimport { ExportSettings } from \"../base-list/models/export.model\";\nimport { defaultIcons, NiceBaseIconOptions } from \"../base-list/models/icons.model\";\nimport { NiceFilterService } from \"../base-list/providers/base-filter.service\";\nimport { NiceFilterDataDirective } from \"./components/common/data.directive\";\nimport { NiceFilterCustomDataViewComponent } from \"./components/custom-data-view/custom-data-view.component\";\nimport { NiceFilterExportButtonsComponent } from \"./components/export-buttons/export-buttons.component\";\nimport { NiceFilterExportDirective } from \"./components/export-buttons/export.directive\";\nimport { NiceFilterInfiniteScrollDataViewComponent } from \"./components/infinite-scroll-data-view/infinite-scroll-data-view.component\";\nimport { NiceFilterSearchComponent } from \"./components/search/search.component\";\nimport { NiceFilterMatPaginatorPaginationDirective } from \"./directives/mat-paginator\";\nimport { NiceFilterMatSortSortingDirective } from \"./directives/mat-sort\";\nimport { NiceFilterMatTableViewDirective } from \"./directives/mat-tables\";\nimport { NiceFilterQueryParamsDirective } from \"./directives/query-params.directive\";\n\nimport { NiceFilterViewComponent } from \"./nice-filter-view.component\";\nimport { EXPORTS_SETTINGS, FILTER_VIEW_ICONS, FILTER_VIEW_STATE } from \"./nice-filter-view.constant\";\nimport { NiceFilterViewState } from \"./store/nice-filter-view.store\";\n\nexport interface NiceFilterViewOptions<T> {\n    filterService: Type<NiceFilterService<T>>;\n    exports?: ExportSettings;\n    state?: Partial<NiceFilterViewState>;\n}\n\nexport interface NiceFilterViewGlobalOptions {\n    icons?: NiceBaseIconOptions;\n}\n\n@NgModule({\n    imports: [\n        TranslateModule,\n        MatIconModule,\n        FormsModule,\n        AsyncPipe,\n        NgIf,\n        NgTemplateOutlet,\n        MatTooltipModule,\n        MatButtonModule,\n        MatBottomSheetModule,\n\n        NiceExportBottomSheetModule\n    ],\n    declarations: [\n        NiceFilterViewComponent,\n        NiceFilterCustomDataViewComponent,\n        NiceFilterExportButtonsComponent,\n        NiceFilterInfiniteScrollDataViewComponent,\n        NiceFilterSearchComponent,\n\n        NiceFilterDataDirective,\n        NiceFilterExportDirective,\n        NiceFilterMatTableViewDirective,\n        NiceFilterMatSortSortingDirective,\n        NiceFilterMatPaginatorPaginationDirective,\n        NiceFilterQueryParamsDirective\n    ],\n    providers: [],\n    exports: [\n        NiceFilterViewComponent,\n        NiceFilterCustomDataViewComponent,\n        NiceFilterExportButtonsComponent,\n        NiceFilterInfiniteScrollDataViewComponent,\n        NiceFilterSearchComponent,\n\n        NiceFilterDataDirective,\n        NiceFilterExportDirective,\n        NiceFilterMatTableViewDirective,\n        NiceFilterMatSortSortingDirective,\n        NiceFilterMatPaginatorPaginationDirective,\n        NiceFilterQueryParamsDirective\n    ],\n})\nexport class NiceFilterViewModule {\n    public static forRoot(options?: NiceFilterViewGlobalOptions): ModuleWithProviders<NiceFilterViewModule> {\n        return {\n            ngModule: NiceFilterViewModule,\n            providers: [\n                {\n                    provide: FILTER_VIEW_ICONS,\n                    useValue: {\n                        ...defaultIcons,\n                        ...(options?.icons ?? {})\n                    }\n                }\n            ].filter(x => !!x)\n        };\n    }\n\n    public static providerFactory<T>(options: NiceFilterViewOptions<T>): Provider[] {\n        return [\n            {\n                provide: NiceFilterService,\n                useClass: options.filterService\n            },\n            {\n                provide: EXPORTS_SETTINGS,\n                useValue: options.exports ?? {\n                    pdf: true,\n                    xlsx: true,\n                    csv: true\n                }\n            },\n            {\n                provide: FILTER_VIEW_STATE,\n                useValue: options.state ?? {}\n            }\n        ].filter(x => !!x);\n    }\n}\n"]}

package/esm2020/lib/components/nice-filter-view/public-api.mjs

@@ -0,0 +1,16 @@
+export * from "./components/common/data.directive";
+export * from "./components/custom-data-view/custom-data-view.component";
+export * from "./components/export-buttons/export-buttons.component";
+export * from "./components/export-buttons/export.directive";
+export * from "./components/infinite-scroll-data-view/infinite-scroll-data-view.component";
+export * from "./components/search/search.component";
+export * from "./directives/mat-paginator";
+export * from "./directives/mat-sort";
+export * from "./directives/mat-tables";
+export * from "./directives/query-params.directive";
+export * from "./store/nice-filter-view.service";
+export * from "./store/nice-filter-view.query";
+export * from "./nice-base-filter-view.component";
+export * from "./nice-filter-view.component";
+export * from "./nice-filter-view.module";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25pY2UtZGF0YS1maWx0ZXIta2l0L3NyYy9saWIvY29tcG9uZW50cy9uaWNlLWZpbHRlci12aWV3L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLDBEQUEwRCxDQUFDO0FBQ3pFLGNBQWMsc0RBQXNELENBQUM7QUFDckUsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLDRFQUE0RSxDQUFDO0FBQzNGLGNBQWMsc0NBQXNDLENBQUM7QUFFckQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUVwRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb21wb25lbnRzL2NvbW1vbi9kYXRhLmRpcmVjdGl2ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29tcG9uZW50cy9jdXN0b20tZGF0YS12aWV3L2N1c3RvbS1kYXRhLXZpZXcuY29tcG9uZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21wb25lbnRzL2V4cG9ydC1idXR0b25zL2V4cG9ydC1idXR0b25zLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29tcG9uZW50cy9leHBvcnQtYnV0dG9ucy9leHBvcnQuZGlyZWN0aXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21wb25lbnRzL2luZmluaXRlLXNjcm9sbC1kYXRhLXZpZXcvaW5maW5pdGUtc2Nyb2xsLWRhdGEtdmlldy5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbXBvbmVudHMvc2VhcmNoL3NlYXJjaC5jb21wb25lbnRcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vZGlyZWN0aXZlcy9tYXQtcGFnaW5hdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kaXJlY3RpdmVzL21hdC1zb3J0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kaXJlY3RpdmVzL21hdC10YWJsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RpcmVjdGl2ZXMvcXVlcnktcGFyYW1zLmRpcmVjdGl2ZVwiO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9zdG9yZS9uaWNlLWZpbHRlci12aWV3LnNlcnZpY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0b3JlL25pY2UtZmlsdGVyLXZpZXcucXVlcnlcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vbmljZS1iYXNlLWZpbHRlci12aWV3LmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbmljZS1maWx0ZXItdmlldy5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL25pY2UtZmlsdGVyLXZpZXcubW9kdWxlXCI7XG4iXX0=

package/esm2020/lib/components/nice-filter-view/store/nice-filter-view.query.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from "@angular/core";
+import { QueryEntity } from "@datorama/akita";
+import { NiceFilterViewStore } from "./nice-filter-view.store";
+import * as i0 from "@angular/core";
+import * as i1 from "./nice-filter-view.store";
+export class NiceFilterViewQuery extends QueryEntity {
+    constructor(store) {
+        super(store);
+        this.store = store;
+    }
+    selectFilterConfigLoading() {
+        return this.select("filterConfigLoading");
+    }
+    selectFilterConfig() {
+        return this.select("filterConfig");
+    }
+    selectFilterParameters() {
+        return this.select("filterParameters");
+    }
+    selectFilterResult() {
+        return this.select("filterResult");
+    }
+}
+NiceFilterViewQuery.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewQuery, deps: [{ token: i1.NiceFilterViewStore }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceFilterViewQuery.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewQuery });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewQuery, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NiceFilterViewStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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