@recursyve/nice-data-filter-kit 14.0.7 → 14.1.1

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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

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

@@ -0,0 +1,229 @@
+import { Inject, Injectable } from "@angular/core";
+import { FileUtils } from "@recursyve/nice-ui-kit.v2";
+import { firstValueFrom } from "rxjs";
+import { NiceFilterService } from "../../base-list/providers/base-filter.service";
+import { NiceFilterViewStore } from "./nice-filter-view.store";
+import * as i0 from "@angular/core";
+import * as i1 from "./nice-filter-view.store";
+export class NiceFilterViewService {
+    constructor(store, filterService) {
+        this.store = store;
+        this.filterService = filterService;
+    }
+    reset() {
+        this.store.reset();
+    }
+    disable() {
+        this.store.update({
+            disabled: true
+        });
+    }
+    enable() {
+        this.store.update({
+            disabled: false
+        });
+    }
+    setAutoLoad(autoLoad) {
+        this.store.update({ autoLoad });
+    }
+    setLoading(loading) {
+        this.store.setLoading(loading);
+    }
+    setMode(mode) {
+        this.store.update({ mode });
+    }
+    async loadConfig(configQueryParams = {}) {
+        this.store.setFilterConfigLoading(true);
+        try {
+            const filterConfig = await firstValueFrom(this.filterService.getFilterConfig({ params: configQueryParams }));
+            this.store.update({
+                filterConfig
+            });
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setFilterConfigLoading(false);
+        }
+    }
+    async filter() {
+        const { filterParameters, disabled } = this.store.getValue();
+        if (disabled) {
+            return;
+        }
+        try {
+            this.store.setLoading(true);
+            const result = await firstValueFrom(this.filterService.filter(this.getParameters(filterParameters)));
+            this.store.setResult(result);
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+        }
+    }
+    async downloadData(type, downloadFileName) {
+        const { filterParameters, disabled } = this.store.getValue();
+        if (disabled) {
+            return;
+        }
+        try {
+            this.store.setLoading(true);
+            const result = await firstValueFrom(this.filterService.getFile(type, this.getParameters(filterParameters)));
+            FileUtils.downloadFile(`${downloadFileName}.${type}`, result);
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+        }
+    }
+    async printData() {
+        const { filterParameters, disabled } = this.store.getValue();
+        if (disabled) {
+            return;
+        }
+        try {
+            this.store.setLoading(true);
+            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.getParameters(filterParameters)));
+            FileUtils.openPrintableWindow(result);
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+        }
+    }
+    setParameters(filterParameters, reload = false) {
+        this.store.setParameters(filterParameters);
+        if (reload) {
+            this.filter();
+        }
+    }
+    resetPaging() {
+        const { filterParameters } = this.store.getValue();
+        this.setParameters({
+            ...filterParameters,
+            start: 0
+        }, false);
+        this.resetResult(true);
+    }
+    setQueryParams(queryParams) {
+        this.store.update({ queryParams });
+    }
+    setBaseRules(rule, reload) {
+        this.store.update({
+            baseRules: rule
+        });
+        if (reload) {
+            this.filter();
+        }
+    }
+    setRules(rules, reload) {
+        if (!Array.isArray(rules)) {
+            rules = [rules];
+        }
+        const { filterParameters } = this.store.getValue();
+        const newRules = {
+            order: filterParameters.order,
+            rules
+        };
+        this.setParameters(newRules, reload);
+    }
+    upsertRule(id, newRule, reload) {
+        const { filterParameters } = this.store.getValue();
+        const currentQuery = filterParameters.rules?.[0];
+        const rule = {
+            id,
+            ...newRule
+        };
+        const query = { rules: [rule], condition: "and" };
+        if (!currentQuery || currentQuery.rules.length === 0) {
+            this.setRules(query, reload);
+            return;
+        }
+        const oldRule = currentQuery.rules.find((r) => r.id === id);
+        let newRules = currentQuery.rules;
+        if (oldRule) {
+            if (newRule) {
+                // Array replace
+                newRules = [
+                    ...currentQuery.rules.slice(0, currentQuery.rules.indexOf(oldRule)),
+                    query,
+                    ...currentQuery.rules.slice(currentQuery.rules.indexOf(oldRule) + 1, currentQuery.rules.length)
+                ];
+            }
+            else {
+                newRules = currentQuery.rules.filter((r) => r.id !== id);
+            }
+        }
+        else {
+            newRules = [...newRules, query];
+        }
+        this.setRules({
+            condition: currentQuery.condition,
+            rules: newRules
+        }, reload);
+    }
+    removeRule(id, reload) {
+        const { filterParameters } = this.store.getValue();
+        const currentQuery = filterParameters.rules?.[0];
+        const oldRule = currentQuery.rules.find((r) => r.id === id);
+        if (!oldRule) {
+            return;
+        }
+        const newRules = currentQuery.rules.filter((r) => r.id !== id);
+        this.setRules({
+            condition: currentQuery.condition,
+            rules: newRules
+        }, reload);
+    }
+    addValue(value, opts) {
+        this.store.addValue(value, opts);
+    }
+    upsertValue(value, key = "id") {
+        this.store.upsertValue(value, key);
+    }
+    removeValue(value, key = "id") {
+        this.store.removeValue(value, key);
+    }
+    resetResult(waitForNextFilter) {
+        if (!waitForNextFilter) {
+            this.store.update({
+                filterResult: null
+            });
+        }
+        else {
+            this.store.update({
+                resetResult: true
+            });
+        }
+    }
+    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: i1.NiceFilterViewStore }, { token: NiceFilterService }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceFilterViewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceFilterViewService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NiceFilterViewStore }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NiceFilterService]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nice-filter-view.service.js","sourceRoot":"","sources":["../../../../../../../projects/nice-data-filter-kit/src/lib/components/nice-filter-view/store/nice-filter-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from \"@angular/core\";\nimport { AddEntitiesOptions } from \"@datorama/akita/src/lib/addEntities\";\nimport { FileUtils } from \"@recursyve/nice-ui-kit.v2\";\nimport { firstValueFrom } from \"rxjs\";\nimport { QueryParams } from \"../../../api/filter.api\";\nimport { FilterParametersModel } from \"../../../models/filter.model\";\nimport { QueryModel, QueryRuleModel, RuleModel } from \"../../../models/query.model\";\nimport { NiceFilterService } from \"../../base-list/providers/base-filter.service\";\nimport { NiceFilterViewStore } from \"./nice-filter-view.store\";\n\n@Injectable()\nexport class NiceFilterViewService<Filter extends NiceFilterService<any> = NiceFilterService<any>> {\n    constructor(\n        private store: NiceFilterViewStore,\n        @Inject(NiceFilterService)\n        public readonly filterService: Filter\n    ) {}\n\n    public reset(): void {\n        this.store.reset();\n    }\n\n    public disable(): void {\n        this.store.update({\n            disabled: true\n        });\n    }\n\n    public enable(): void {\n        this.store.update({\n            disabled: false\n        });\n    }\n\n    public setAutoLoad(autoLoad: boolean): void {\n        this.store.update({ autoLoad });\n    }\n\n    public setLoading(loading: boolean): void {\n        this.store.setLoading(loading);\n    }\n\n    public setMode(mode: \"paginated\" | \"accumulated\"): void {\n        this.store.update({ mode });\n    }\n\n    public async loadConfig(configQueryParams: QueryParams = {}): Promise<void> {\n        this.store.setFilterConfigLoading(true);\n        try {\n            const filterConfig = await firstValueFrom(this.filterService.getFilterConfig({ params: configQueryParams }));\n            this.store.update({\n                filterConfig\n            });\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setFilterConfigLoading(false);\n        }\n    }\n\n    public async filter(): Promise<void> {\n        const { filterParameters, disabled } = this.store.getValue();\n        if (disabled) {\n            return;\n        }\n\n        try {\n            this.store.setLoading(true);\n            const result = await firstValueFrom(this.filterService.filter(this.getParameters(filterParameters)));\n            this.store.setResult(result);\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n        }\n    }\n\n    public async downloadData(type: string, downloadFileName: string): Promise<void> {\n        const { filterParameters, disabled } = this.store.getValue();\n        if (disabled) {\n            return;\n        }\n\n        try {\n            this.store.setLoading(true);\n            const result = await firstValueFrom(this.filterService.getFile(type, this.getParameters(filterParameters)));\n            FileUtils.downloadFile(`${downloadFileName}.${type}`, result);\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n        }\n    }\n\n    public async printData(): Promise<void> {\n        const { filterParameters, disabled } = this.store.getValue();\n        if (disabled) {\n            return;\n        }\n\n        try {\n            this.store.setLoading(true);\n            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.getParameters(filterParameters)));\n            FileUtils.openPrintableWindow(result);\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n        }\n    }\n\n    public setParameters(filterParameters: FilterParametersModel, reload = false): void {\n        this.store.setParameters(filterParameters);\n        if (reload) {\n            this.filter();\n        }\n    }\n\n    public resetPaging(): void {\n        const { filterParameters } = this.store.getValue();\n        this.setParameters({\n            ...filterParameters,\n            start: 0\n        }, false);\n\n        this.resetResult(true);\n    }\n\n    public setQueryParams(queryParams: QueryParams): void {\n        this.store.update({ queryParams });\n    }\n\n    public setBaseRules(rule: (QueryRuleModel | QueryModel)[], reload: boolean): void {\n        this.store.update({\n            baseRules: rule\n        });\n\n        if (reload) {\n            this.filter();\n        }\n    }\n\n    public setRules(rules: QueryModel | QueryModel[], reload: boolean): void {\n        if (!Array.isArray(rules)) {\n            rules = [rules];\n        }\n\n        const { filterParameters } = this.store.getValue();\n        const newRules: FilterParametersModel = {\n            order: filterParameters.order,\n            rules\n        };\n\n        this.setParameters(newRules, reload);\n    }\n\n    public upsertRule(id: string, newRule: RuleModel, reload: boolean): void {\n        const { filterParameters } = this.store.getValue();\n        const currentQuery = filterParameters.rules?.[0];\n        const rule: QueryRuleModel = {\n            id,\n            ...newRule\n        };\n        const query: QueryModel = { rules: [rule], condition: \"and\" };\n        if (!currentQuery || currentQuery.rules.length === 0) {\n            this.setRules(query , reload);\n            return;\n        }\n\n        const oldRule = currentQuery.rules.find((r) => (r as QueryRuleModel).id === id) as QueryRuleModel;\n        let newRules = currentQuery.rules;\n        if (oldRule) {\n            if (newRule) {\n                // Array replace\n                newRules = [\n                    ...currentQuery.rules.slice(0, currentQuery.rules.indexOf(oldRule)),\n                    query,\n                    ...currentQuery.rules.slice(currentQuery.rules.indexOf(oldRule) + 1, currentQuery.rules.length)\n                ];\n            } else {\n                newRules = currentQuery.rules.filter((r) => (r as QueryRuleModel).id !== id);\n            }\n        } else {\n            newRules = [...newRules, query];\n        }\n        this.setRules({\n            condition: currentQuery.condition,\n            rules: newRules\n        }, reload);\n    }\n\n    public removeRule(id: string, reload: boolean): void {\n        const { filterParameters } = this.store.getValue();\n        const currentQuery = filterParameters.rules?.[0];\n        const oldRule = currentQuery.rules.find((r) => (r as QueryRuleModel).id === id) as QueryRuleModel;\n        if (!oldRule) {\n            return;\n        }\n\n        const newRules = currentQuery.rules.filter((r) => (r as QueryRuleModel).id !== id);\n        this.setRules({\n            condition: currentQuery.condition,\n            rules: newRules\n        }, reload);\n    }\n\n    public addValue(value: any, opts?: AddEntitiesOptions): void {\n        this.store.addValue(value, opts);\n    }\n\n    public upsertValue(value: any, key = \"id\"): void {\n        this.store.upsertValue(value, key);\n    }\n\n    public removeValue(value: any, key = \"id\"): void {\n        this.store.removeValue(value, key);\n    }\n\n    public resetResult(waitForNextFilter: boolean): void {\n        if (!waitForNextFilter) {\n            this.store.update({\n                filterResult: null\n            });\n        } else {\n            this.store.update({\n                resetResult: true\n            });\n        }\n    }\n\n    public getParameters(filterParameters?: FilterParametersModel): FilterParametersModel {\n        const { baseRules } = this.store.getValue();\n        const parameters = {\n            ...filterParameters,\n            rules: filterParameters?.rules ? [...filterParameters.rules] : []\n        };\n        if (baseRules?.length) {\n            parameters.rules.push({\n                condition: \"and\",\n                rules: baseRules\n            });\n        }\n        return parameters;\n    }\n}\n"]}