@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/filter/filter-service/filter.service.mjs

@@ -0,0 +1,206 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { of, ReplaySubject, take } from 'rxjs';
+import { Store } from '@ngrx/store';
+import { QdFilterActions } from '../store/filter.actions';
+import { QdFilterSelector, selectItem } from '../store/filter.selector';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngx-translate/core";
+export class QdFilterService {
+    store;
+    translateService;
+    queryStringSubjects = [];
+    filterUrlParameterSubjects = [];
+    postBodySubjects = [];
+    constructor(store, translateService) {
+        this.store = store;
+        this.translateService = translateService;
+    }
+    getItems$(filterId, categoryIndex) {
+        return this.store.select(QdFilterSelector.selectItems, {
+            filterId,
+            categoryIndex
+        });
+    }
+    getItemById$(filterId, categoryIndex, itemIndex) {
+        return this.store.select(selectItem(filterId, categoryIndex, itemIndex));
+    }
+    getMinDate$(filterId, categoryIndex, itemIndex) {
+        return itemIndex === 1
+            ? this.store.select(QdFilterSelector.selectItemDate, {
+                categoryIndex,
+                itemIndex: 0,
+                filterId
+            })
+            : of(undefined);
+    }
+    getMaxDate$(filterId, categoryIndex, itemIndex) {
+        return itemIndex === 0
+            ? this.store.select(QdFilterSelector.selectItemDate, {
+                categoryIndex,
+                itemIndex: 1,
+                filterId
+            })
+            : of(undefined);
+    }
+    getQueryString$(filterId) {
+        return this.getQueryStringSubject(filterId).asObservable();
+    }
+    getFilterUrlParameter$(filterId) {
+        return this.getFilterUrlParameterSubject(filterId).asObservable();
+    }
+    getPostBody$(filterId) {
+        return this.getPostBodySubject(filterId).asObservable();
+    }
+    emitQueryString(filterId, outputLegacyQueryStringFormat) {
+        this.getCurrentQueryString(filterId, outputLegacyQueryStringFormat)
+            .pipe(take(1))
+            .subscribe(queryString => {
+            this.getQueryStringSubject(filterId).next(queryString);
+        });
+    }
+    getCurrentQueryString(filterId, outputLegacyQueryStringFormat) {
+        return this.store.select(state => QdFilterSelector.selectQueryString(state, { filterId, outputLegacyQueryStringFormat }));
+    }
+    emitFilterUrlParameterString(filterId) {
+        this.getCurrentFilterUrlParameterString(filterId)
+            .pipe(take(1))
+            .subscribe(queryString => {
+            this.getFilterUrlParameterSubject(filterId).next(queryString);
+        });
+    }
+    getCurrentFilterUrlParameterString(filterId) {
+        return this.store.select(state => QdFilterSelector.selectFilterUrlParameter(state, { filterId }));
+    }
+    emitPostBody(filterId) {
+        this.getCurrentPostBody(filterId)
+            .pipe(take(1))
+            .subscribe(postBody => {
+            this.getPostBodySubject(filterId).next(postBody);
+        });
+    }
+    getCurrentPostBody(filterId) {
+        return this.store.select(state => QdFilterSelector.selectPostBody(state, { filterId }));
+    }
+    /**
+     * State Selector
+     */
+    selectFilterDataById$(filterId) {
+        return this.store.select(QdFilterSelector.selectFilterDataById, { filterId });
+    }
+    selectHasActiveCategory$(filterId) {
+        return this.store.select(QdFilterSelector.selectHasActiveCategory, { filterId });
+    }
+    getCategoryById$(filterId, categoryIndex) {
+        return this.store.select(QdFilterSelector.selectCategoryById, {
+            filterId,
+            categoryIndex
+        });
+    }
+    getFilterCategoryValue$(filterId, categoryIndex) {
+        return this.store.select(QdFilterSelector.selectFilterCategoryValue, {
+            filterId,
+            categoryIndex
+        });
+    }
+    /**
+     * Action dispatcher
+     */
+    initFilterState(filterId, filterData) {
+        this.store.dispatch(QdFilterActions.initFilterState({ filterId, filterData }));
+    }
+    updateItem(filterId, categoryIndex, itemIndex, value) {
+        this.store.dispatch(QdFilterActions.updateItem({
+            filterId,
+            categoryIndex,
+            itemIndex,
+            value
+        }));
+    }
+    updateCategoryItems(filterId, categoryIndex, items) {
+        this.store.dispatch(QdFilterActions.updateCategoryItems({
+            filterId,
+            categoryIndex,
+            items
+        }));
+    }
+    setItemIsActive(filterId, categoryIndex, itemIndex, isActive) {
+        this.store.dispatch(QdFilterActions.setItemIsActive({
+            categoryIndex,
+            itemIndex,
+            isActive,
+            filterId
+        }));
+    }
+    setItemsStateSingleSelect(filterId, categoryIndex, itemIndex) {
+        this.store.dispatch(QdFilterActions.setItemsStateSingleSelect({
+            categoryIndex,
+            itemIndex,
+            filterId
+        }));
+    }
+    hideShowItems(filterId, categoryIndex, filterKey) {
+        this.store.dispatch(QdFilterActions.hideShowItems({
+            filterId,
+            categoryIndex,
+            filterKey,
+            translateFunc: key => this.translateService.instant(key)
+        }));
+    }
+    updateCategoryTranslation(filterId, filterData) {
+        this.store.dispatch(QdFilterActions.updateCategoryTranslation({
+            filterId,
+            filterData
+        }));
+    }
+    setFilterSelection(filterId, filterSelection) {
+        this.store.dispatch(QdFilterActions.setFilterSelection({
+            filterId,
+            filterSelection
+        }));
+    }
+    resetEmissionReplaySubjects(filterId) {
+        this.queryStringSubjects[filterId] = new ReplaySubject(1);
+        this.postBodySubjects[filterId] = new ReplaySubject(1);
+        this.filterUrlParameterSubjects[filterId] = new ReplaySubject(1);
+    }
+    setCategoryFilter(filterId, categoryIndex, filter) {
+        this.store.dispatch(QdFilterActions.setCategoryFilter({
+            filterId,
+            categoryIndex,
+            filter
+        }));
+    }
+    resetCategoryFilter(filterId, categoryIndex) {
+        this.store.dispatch(QdFilterActions.resetCategoryFilter({
+            filterId,
+            categoryIndex
+        }));
+    }
+    getQueryStringSubject(filterId) {
+        if (!this.queryStringSubjects[filterId])
+            this.queryStringSubjects[filterId] = new ReplaySubject(1);
+        return this.queryStringSubjects[filterId];
+    }
+    getFilterUrlParameterSubject(filterId) {
+        if (!this.filterUrlParameterSubjects[filterId])
+            this.filterUrlParameterSubjects[filterId] = new ReplaySubject(1);
+        return this.filterUrlParameterSubjects[filterId];
+    }
+    getPostBodySubject(filterId) {
+        if (!this.postBodySubjects[filterId])
+            this.postBodySubjects[filterId] = new ReplaySubject(1);
+        return this.postBodySubjects[filterId];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFilterService, deps: [{ token: i1.Store }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFilterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Store }, { type: i2.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/filter/filter-service/filter.service.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Injectable } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Observable, of, ReplaySubject, Subject, take } from 'rxjs';\nimport { Store } from '@ngrx/store';\n\nimport { QdFilterCategory, QdFilterItem, QdFilterSelection } from '../model/filter-config.interface';\nimport { QdFilterPostBodyData } from '../model/filter-post-body.interface';\nimport { QdFilterActions } from '../store/filter.actions';\nimport { QdFilterSelector, QdFilterState, selectItem } from '../store/filter.selector';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class QdFilterService {\n  private queryStringSubjects: ReplaySubject<string>[] = [];\n  private filterUrlParameterSubjects: ReplaySubject<string>[] = [];\n  private postBodySubjects: ReplaySubject<QdFilterPostBodyData>[] = [];\n\n  constructor(private readonly store: Store<QdFilterState>, public readonly translateService: TranslateService) {}\n\n  getItems$(filterId, categoryIndex): Observable<any> {\n    return this.store.select(QdFilterSelector.selectItems, {\n      filterId,\n      categoryIndex\n    });\n  }\n\n  getItemById$(filterId, categoryIndex, itemIndex): Observable<QdFilterItem> {\n    return this.store.select(selectItem(filterId, categoryIndex, itemIndex));\n  }\n\n  getMinDate$(filterId, categoryIndex, itemIndex): Observable<string | undefined> {\n    return itemIndex === 1\n      ? this.store.select(QdFilterSelector.selectItemDate, {\n          categoryIndex,\n          itemIndex: 0,\n          filterId\n        })\n      : of(undefined);\n  }\n\n  getMaxDate$(filterId, categoryIndex, itemIndex): Observable<string | undefined> {\n    return itemIndex === 0\n      ? this.store.select(QdFilterSelector.selectItemDate, {\n          categoryIndex,\n          itemIndex: 1,\n          filterId\n        })\n      : of(undefined);\n  }\n\n  getQueryString$(filterId): Observable<string> {\n    return this.getQueryStringSubject(filterId).asObservable();\n  }\n\n  getFilterUrlParameter$(filterId): Observable<string> {\n    return this.getFilterUrlParameterSubject(filterId).asObservable();\n  }\n\n  getPostBody$(filterId): Observable<QdFilterPostBodyData> {\n    return this.getPostBodySubject(filterId).asObservable();\n  }\n\n  emitQueryString(filterId: string, outputLegacyQueryStringFormat: boolean): void {\n    this.getCurrentQueryString(filterId, outputLegacyQueryStringFormat)\n      .pipe(take(1))\n      .subscribe(queryString => {\n        this.getQueryStringSubject(filterId).next(queryString);\n      });\n  }\n\n  getCurrentQueryString(filterId: string, outputLegacyQueryStringFormat: boolean): Observable<string> {\n    return this.store.select(state =>\n      QdFilterSelector.selectQueryString(state, { filterId, outputLegacyQueryStringFormat })\n    );\n  }\n\n  emitFilterUrlParameterString(filterId: string): void {\n    this.getCurrentFilterUrlParameterString(filterId)\n      .pipe(take(1))\n      .subscribe(queryString => {\n        this.getFilterUrlParameterSubject(filterId).next(queryString);\n      });\n  }\n\n  getCurrentFilterUrlParameterString(filterId: string): Observable<string> {\n    return this.store.select(state => QdFilterSelector.selectFilterUrlParameter(state, { filterId }));\n  }\n\n  emitPostBody(filterId): void {\n    this.getCurrentPostBody(filterId)\n      .pipe(take(1))\n      .subscribe(postBody => {\n        this.getPostBodySubject(filterId).next(postBody);\n      });\n  }\n\n  getCurrentPostBody(filterId): Observable<QdFilterPostBodyData> {\n    return this.store.select(state => QdFilterSelector.selectPostBody(state, { filterId }));\n  }\n\n  /**\n   * State Selector\n   */\n  selectFilterDataById$(filterId): Observable<QdFilterCategory[]> {\n    return this.store.select(QdFilterSelector.selectFilterDataById, { filterId });\n  }\n\n  selectHasActiveCategory$(filterId): Observable<boolean> {\n    return this.store.select(QdFilterSelector.selectHasActiveCategory, { filterId });\n  }\n\n  getCategoryById$(filterId, categoryIndex): Observable<any> {\n    return this.store.select(QdFilterSelector.selectCategoryById, {\n      filterId,\n      categoryIndex\n    });\n  }\n\n  getFilterCategoryValue$(filterId, categoryIndex): Observable<any> {\n    return this.store.select(QdFilterSelector.selectFilterCategoryValue, {\n      filterId,\n      categoryIndex\n    });\n  }\n\n  /**\n   * Action dispatcher\n   */\n  initFilterState(filterId, filterData): void {\n    this.store.dispatch(QdFilterActions.initFilterState({ filterId, filterData }));\n  }\n\n  updateItem(filterId, categoryIndex, itemIndex, value): void {\n    this.store.dispatch(\n      QdFilterActions.updateItem({\n        filterId,\n        categoryIndex,\n        itemIndex,\n        value\n      })\n    );\n  }\n\n  updateCategoryItems(filterId, categoryIndex, items): void {\n    this.store.dispatch(\n      QdFilterActions.updateCategoryItems({\n        filterId,\n        categoryIndex,\n        items\n      })\n    );\n  }\n\n  setItemIsActive(filterId, categoryIndex, itemIndex, isActive): void {\n    this.store.dispatch(\n      QdFilterActions.setItemIsActive({\n        categoryIndex,\n        itemIndex,\n        isActive,\n        filterId\n      })\n    );\n  }\n\n  setItemsStateSingleSelect(filterId, categoryIndex, itemIndex): void {\n    this.store.dispatch(\n      QdFilterActions.setItemsStateSingleSelect({\n        categoryIndex,\n        itemIndex,\n        filterId\n      })\n    );\n  }\n\n  hideShowItems(filterId, categoryIndex, filterKey): void {\n    this.store.dispatch(\n      QdFilterActions.hideShowItems({\n        filterId,\n        categoryIndex,\n        filterKey,\n        translateFunc: key => this.translateService.instant(key)\n      })\n    );\n  }\n\n  updateCategoryTranslation(filterId, filterData): void {\n    this.store.dispatch(\n      QdFilterActions.updateCategoryTranslation({\n        filterId,\n        filterData\n      })\n    );\n  }\n\n  setFilterSelection(filterId, filterSelection: QdFilterSelection): void {\n    this.store.dispatch(\n      QdFilterActions.setFilterSelection({\n        filterId,\n        filterSelection\n      })\n    );\n  }\n\n  resetEmissionReplaySubjects(filterId): void {\n    this.queryStringSubjects[filterId] = new ReplaySubject<string>(1);\n    this.postBodySubjects[filterId] = new ReplaySubject<QdFilterPostBodyData>(1);\n    this.filterUrlParameterSubjects[filterId] = new ReplaySubject<string>(1);\n  }\n\n  setCategoryFilter(filterId, categoryIndex: number, filter: string): void {\n    this.store.dispatch(\n      QdFilterActions.setCategoryFilter({\n        filterId,\n        categoryIndex,\n        filter\n      })\n    );\n  }\n\n  resetCategoryFilter(filterId: string, categoryIndex: number): void {\n    this.store.dispatch(\n      QdFilterActions.resetCategoryFilter({\n        filterId,\n        categoryIndex\n      })\n    );\n  }\n\n  private getQueryStringSubject(filterId): Subject<string> {\n    if (!this.queryStringSubjects[filterId]) this.queryStringSubjects[filterId] = new ReplaySubject<string>(1);\n\n    return this.queryStringSubjects[filterId];\n  }\n\n  private getFilterUrlParameterSubject(filterId): Subject<string> {\n    if (!this.filterUrlParameterSubjects[filterId])\n      this.filterUrlParameterSubjects[filterId] = new ReplaySubject<string>(1);\n\n    return this.filterUrlParameterSubjects[filterId];\n  }\n\n  private getPostBodySubject(filterId): Subject<QdFilterPostBodyData> {\n    if (!this.postBodySubjects[filterId]) this.postBodySubjects[filterId] = new ReplaySubject<QdFilterPostBodyData>(1);\n\n    return this.postBodySubjects[filterId];\n  }\n}\n"]}

package/esm2022/lib/filter/filter.component.mjs

@@ -0,0 +1,308 @@
+// @ts-strict-ignore
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, HostBinding, Input, Output, QueryList, ViewChildren } from '@angular/core';
+import { diff } from 'deep-object-diff';
+import { BehaviorSubject, combineLatest, delay, firstValueFrom, from, merge, ReplaySubject, switchMap, tap } from 'rxjs';
+import { distinctUntilChanged, filter, map, skip, take } from 'rxjs/operators';
+import { v4 as uuid } from 'uuid';
+import * as _ from 'lodash';
+import { QdFilterCategoryComponent } from './category/filter-category.component';
+import { QdFilterService } from './filter-service/filter.service';
+import { hasActiveCategory } from './helpers/filter-active.helper';
+import { QdFilterRouterConnectorService } from './services/filter-router-connector.service';
+import { QdDependentFiltersService } from './services/dependent-filters.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./filter-service/filter.service";
+import * as i2 from "./services/filter-router-connector.service";
+import * as i3 from "./services/dependent-filters.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../button/button/button.component";
+import * as i6 from "../button/directives/button.directives";
+import * as i7 from "./category/filter-category.component";
+import * as i8 from "@ngx-translate/core";
+/**
+ * The **QdFilter** is responsible for the filtering of data.
+ *
+ * Hirarchical structure::
+ * - **Filter**: Name of the component.
+ * - **Categories**: A list of one or more different categories.
+ * - **Items**: A list with one or more items belongs to a parent category.
+ *
+ * ### Filter selection ###
+ *
+ * To get the applied filters you can listen to the outputs `(queryStringOutput)` and `(postBodyOutput)`.
+ * These outputs will be emitted when the filter is triggered. The `(queryStringOutput)` returns
+ * the applied filters as an url string with an encoded *filter* parameter. The `(postBodyOutput)`
+ * yields an object containing the categories and active items.
+ *
+ * In addition to the outputs, you also can query the current filter selection with the
+ * filter component methods `getCurrentQueryString`, `getCurrentFilterUrlParameterString` and `getCurrentPostBody`.
+ *
+ * ### Preserve filter state ###
+ *
+ * To preserve the filter state when navigating, for example between detail and overview page, you just have to define
+ * a uid in the filter data config.
+ *
+ * ### Multi Staging Filters
+ *
+ * To build a dependency chain of filters you can use the `dependsOn` property of a filter that depends on
+ * other filters. In the `dependsOn` property you set the names of the filter categories the category depends on.
+ * Always when one of these categories change the `itemsResolver` will be called with the list
+ * of categories given in `dependsOn`. The `itemsResolver` can also be defined in the config where `dependsOn`
+ * is also defined.
+ *
+ * If the items resolver has not been called yet or when it returns an empty array of items,
+ * the corresponding filter stage won't be rendered.
+ *
+ * #### Support
+ *
+ * Multi Staging Filters only work for `singleSelect` and `multiSelect` filters.
+ *
+ */
+export class QdFilterComponent {
+    filterService;
+    filterRouterConnectorService;
+    dependentFiltersService;
+    /**
+     * The configuration of the filter
+     */
+    set filterData(filterData) {
+        this._filterDataSubject.next(filterData);
+    }
+    get filterData() {
+        return this._filterDataSubject.value;
+    }
+    /**
+     * A static test ID for integration tests can be set. <br />
+     * The value for the HTML attribute [data-test-id].
+     */
+    testId = 'filter';
+    /**
+     * Emits event on click/tap of the filter/reset button of the filter or on deletion of an active item. <br />
+     * Return value is the query string of the filter.
+     */
+    queryStringOutput = new EventEmitter();
+    /**
+     * Emits event on click/tap of the filter/reset button of the filter or on deletion of an active item. <br />
+     * Return value is the result object of the filter.
+     */
+    postBodyOutput = new EventEmitter();
+    /**
+     * Emits event when the values of the filter change. Return value matches the current object of the filter.
+     */
+    valueChange = new EventEmitter();
+    filterCategory;
+    get dataTestId() {
+        return this.testId + '-' + this.filterId;
+    }
+    disableFilterButton$;
+    disableResetButton$;
+    filterId;
+    _queryStringSubscription;
+    _postBodySubscription;
+    _emitOutputsSubscription;
+    _filterValueSubscription;
+    _filterDataSubject = new BehaviorSubject(undefined);
+    _hasPreselectionSubject = new ReplaySubject(1);
+    _categoriesSubject = new ReplaySubject(1);
+    _filterConnectedWithRouterSubject = new ReplaySubject();
+    _filterConnectedWithRouter$ = this._filterConnectedWithRouterSubject.asObservable();
+    set hasPreselection(hasPreselection) {
+        this._hasPreselectionSubject.next(hasPreselection);
+    }
+    get hasPreselection$() {
+        return this._hasPreselectionSubject.asObservable();
+    }
+    set categories(categories) {
+        this._categoriesSubject.next(categories);
+    }
+    get categories$() {
+        return this._categoriesSubject.asObservable();
+    }
+    get isInstantFiltering() {
+        return this.filterData?.isInstantFiltering === true;
+    }
+    constructor(filterService, filterRouterConnectorService, dependentFiltersService) {
+        this.filterService = filterService;
+        this.filterRouterConnectorService = filterRouterConnectorService;
+        this.dependentFiltersService = dependentFiltersService;
+    }
+    async ngOnInit() {
+        await this.waitForFilterData();
+        this.filterId = this.filterData?.uid || uuid();
+        this.validateConfig();
+        this.init();
+    }
+    waitForFilterData() {
+        return firstValueFrom(this._filterDataSubject.pipe(filter(filterData => !!filterData)));
+    }
+    ngOnChanges(changes) {
+        // TODO: Decision: Is there really a need for this???
+        if (this.hasChangesByKey(changes, 'i18n'))
+            this.filterService.updateCategoryTranslation(this.filterId, this.filterData);
+        if (this.hasChangesByKey(changes, 'items') || this.hasChangesByKey(changes, 'filter'))
+            this.filterService.initFilterState(this.filterId, this.filterData);
+        if (this.hasChangesByCategoriesLength(changes)) {
+            this.filterService.initFilterState(this.filterId, this.filterData);
+            this.categories = this.filterData.categories.map(category => category.category);
+        }
+    }
+    ngOnDestroy() {
+        this.filterRouterConnectorService.disconnectFilterFromRouter(this);
+        this.dependentFiltersService.destroy();
+        this._queryStringSubscription?.unsubscribe();
+        this._postBodySubscription?.unsubscribe();
+        this._emitOutputsSubscription?.unsubscribe();
+        this._filterValueSubscription?.unsubscribe();
+        /* the ReplaySubjects would cause an initial emission of the outputs if the component is reinitialized
+         * (when navigating back for example). ReplaySubjects are used here because the subscription of the section
+         * is delayed in the integrated solution with the qdConnectToFilter directive. */
+        this.filterService.resetEmissionReplaySubjects(this.filterId);
+    }
+    clickFilter() {
+        this.filterCategory.forEach(category => category.refreshItems());
+        this.emitOutputs();
+    }
+    async resetFilter() {
+        this.filterService.initFilterState(this.filterId, this.filterData);
+        this.filterCategory.forEach(category => category.handleReset());
+        if (await firstValueFrom(this.hasPreselection$))
+            this.emitOutputs();
+    }
+    emitOutputs() {
+        this.filterService.emitQueryString(this.filterId, this.filterData?.outputLegacyQueryStringFormat !== false);
+        this.filterService.emitFilterUrlParameterString(this.filterId);
+        this.filterService.emitPostBody(this.filterId);
+    }
+    getCurrentQueryString() {
+        return this.filterService.getCurrentQueryString(this.filterId, this.filterData?.outputLegacyQueryStringFormat !== false);
+    }
+    getCurrentFilterUrlParameterString() {
+        return this.filterService.getCurrentFilterUrlParameterString(this.filterId);
+    }
+    getCurrentPostBody() {
+        return this.filterService.getCurrentPostBody(this.filterId);
+    }
+    hasFilterData() {
+        return this.filterData !== undefined;
+    }
+    setFilterConfig(filterData) {
+        this._filterDataSubject.next(filterData);
+    }
+    updateFilterConfig(filterData) {
+        this._filterDataSubject.next(filterData);
+        this.filterService.initFilterState(this.filterId, this.filterData);
+        this.filterService.emitPostBody(this.filterId);
+        this.filterService.emitFilterUrlParameterString(this.filterId);
+    }
+    getFilterChanges$() {
+        return from(this.waitForFilterData()).pipe(
+        // wait for filterId
+        switchMap(() => this._filterConnectedWithRouter$), delay(1), switchMap(() => this.filterService.getPostBody$(this.filterId)));
+    }
+    validateConfig() {
+        if (this.filterData?.outputLegacyQueryStringFormat !== false && this.queryStringOutput.observers.length > 0) {
+            console.warn('QdFilter | You use the queryStringOutput with the legacy format. To use the new format please set outputLegacyQueryStringFormat to false. The legacy format will be removed in future releases.');
+        }
+    }
+    init() {
+        this.reInitFromStoreIfReMounted();
+        this.disableFilterButton$ = this.filterService
+            .selectHasActiveCategory$(this.filterId)
+            .pipe(map(hasActive => !hasActive));
+        this.initResetButtonActivation();
+        this._queryStringSubscription = this.filterService
+            .getQueryString$(this.filterId)
+            .subscribe(queryString => this.queryStringOutput.emit(queryString));
+        this._postBodySubscription = this.filterService
+            .getPostBody$(this.filterId)
+            .subscribe(postBody => this.postBodyOutput.emit(postBody));
+        this.hasPreselection = hasActiveCategory(this.filterData?.categories);
+        this._emitOutputsSubscription = merge(this.hasPreselectionAfterRouterConnection$.pipe(filter(hasPreselection => hasPreselection || this.filterData?.emitOutputsInitially)), this.allFiltersRemoved$).subscribe(() => {
+            this.emitOutputs();
+        });
+        this._filterValueSubscription = this.filterService
+            .getCurrentPostBody(this.filterId)
+            .pipe(distinctUntilChanged(_.isEqual), tap(() => {
+            if (this.isInstantFiltering)
+                this.emitOutputs();
+        }))
+            .subscribe(filterValue => this.valueChange.emit(filterValue));
+        this.initializeDependentFiltersService();
+    }
+    initializeDependentFiltersService() {
+        this.dependentFiltersService.initialize(this);
+        this._filterDataSubject
+            .pipe(skip(1)) // skip current value, only reinitialize for changes
+            .subscribe(() => this.dependentFiltersService.reinitialize());
+    }
+    initResetButtonActivation() {
+        this.disableResetButton$ = combineLatest([
+            this.filterService.selectHasActiveCategory$(this.filterId),
+            this.filterService
+                .selectFilterDataById$(this.filterId)
+                .pipe(map(data => data.map(entry => entry.items).map(items => items.map(item => item).map(item => _.omit(item, ['hidden']))))),
+            this.hasPreselection$
+        ]).pipe(map(([hasActiveCategory, items, hasPreselection]) => {
+            if (hasPreselection) {
+                const categories = _.flatten(this.filterData.categories.map(category => category.items.map(item => ({ active: false, ...item })))).filter(category => category.item);
+                return _.isEqual(_.flatten(items).filter(item => item.item), categories);
+            }
+            return !hasActiveCategory;
+        }));
+    }
+    get hasPreselectionAfterRouterConnection$() {
+        return this.filterRouterConnectorService.connectFilterWithRouter(this).pipe(tap(() => this._filterConnectedWithRouterSubject.next()), switchMap(() => this.filterService.selectHasActiveCategory$(this.filterId)), take(1));
+    }
+    get allFiltersRemoved$() {
+        return this.filterService.selectHasActiveCategory$(this.filterId).pipe(skip(1), filter(someCategoryActive => !someCategoryActive));
+    }
+    hasChangesByKey(changes, key) {
+        const _diff = diff(changes.filterData.currentValue, changes.filterData.previousValue);
+        if (!_diff || !_diff.categories)
+            return false;
+        return Object.values(_diff.categories)?.filter(category => category && category[key] !== undefined).length > 0;
+    }
+    hasChangesByCategoriesLength(changes) {
+        if (changes.filterData.previousValue === undefined)
+            return false;
+        return changes.filterData.currentValue.categories.length !== changes.filterData.previousValue.categories.length;
+    }
+    reInitFromStoreIfReMounted() {
+        this.filterService
+            .selectFilterDataById$(this.filterId)
+            .pipe(take(1))
+            .subscribe(filterCategoriesFromStore => {
+            if (filterCategoriesFromStore.length > 0) {
+                this.categories = filterCategoriesFromStore.map(category => category.category);
+            }
+            else {
+                this.categories = this.filterData?.categories.map(category => category.category);
+                this.filterService.initFilterState(this.filterId, this.filterData);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFilterComponent, deps: [{ token: i1.QdFilterService }, { token: i2.QdFilterRouterConnectorService }, { token: i3.QdDependentFiltersService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFilterComponent, selector: "qd-filter", inputs: { filterData: "filterData", testId: ["data-test-id", "testId"] }, outputs: { queryStringOutput: "queryStringOutput", postBodyOutput: "postBodyOutput", valueChange: "valueChange" }, host: { properties: { "attr.data-test-id": "this.dataTestId" }, classAttribute: "qd-filter" }, providers: [QdDependentFiltersService], viewQueries: [{ propertyName: "filterCategory", predicate: i0.forwardRef(() => QdFilterCategoryComponent), descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"(categories$ | async)?.length > 0\">\n  <ng-container\n    *ngFor=\"let category of categories$ | async; let last = last; let length = count; let categoryIndex = index\"\n  >\n    <qd-filter-category\n      [filterId]=\"filterId\"\n      [isInstantFiltering]=\"isInstantFiltering\"\n      [categoryIndex]=\"categoryIndex\"\n      [lastCategory]=\"last\"\n      [data-test-id]=\"testId + '-category-' + categoryIndex + '-' + category\"\n    ></qd-filter-category>\n  </ng-container>\n\n  <div [class]=\"'qd-filter__action-buttons'\" *ngIf=\"!isInstantFiltering\">\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableFilterButton$ | async\"\n      (click)=\"clickFilter()\"\n      [color]=\"'primary'\"\n      [data-test-id]=\"testId + '-submit-button'\"\n    >\n      {{ \"i18n.qd.container.toolbar.filter.filter\" | translate }}\n    </button>\n\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableResetButton$ | async\"\n      (click)=\"resetFilter()\"\n      [color]=\"'secondary'\"\n      [data-test-id]=\"testId + '-reset-button'\"\n    >\n      {{\n        ((hasPreselection$ | async)\n          ? \"i18n.qd.container.toolbar.filter.backToPreSelect\"\n          : \"i18n.qd.container.toolbar.filter.reset\"\n        ) | translate\n      }}\n    </button>\n  </div>\n</ng-container>\n", styles: [":host{position:relative;display:flex;flex-wrap:wrap}:host .qd-filter__action-buttons{display:flex;flex-wrap:wrap-reverse}:host ::ng-deep .qd-button{position:relative;margin-bottom:1rem}:host ::ng-deep .qd-button:last-child{margin-left:1rem}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.QdButtonComponent, selector: "button[qdButton], a[qdButton], button[qd-button]", inputs: ["disabled", "color", "icon", "data-test-id", "additionalInfo"] }, { kind: "directive", type: i6.QdButtonLinkDirective, selector: "button[qdButtonLink], a[qdButtonLink], button[qd-button-link]" }, { kind: "component", type: i7.QdFilterCategoryComponent, selector: "qd-filter-category", inputs: ["filterId", "isInstantFiltering", "categoryIndex", "lastCategory", "data-test-id"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-filter', changeDetection: ChangeDetectionStrategy.OnPush, host: { class: 'qd-filter' }, providers: [QdDependentFiltersService], template: "<ng-container *ngIf=\"(categories$ | async)?.length > 0\">\n  <ng-container\n    *ngFor=\"let category of categories$ | async; let last = last; let length = count; let categoryIndex = index\"\n  >\n    <qd-filter-category\n      [filterId]=\"filterId\"\n      [isInstantFiltering]=\"isInstantFiltering\"\n      [categoryIndex]=\"categoryIndex\"\n      [lastCategory]=\"last\"\n      [data-test-id]=\"testId + '-category-' + categoryIndex + '-' + category\"\n    ></qd-filter-category>\n  </ng-container>\n\n  <div [class]=\"'qd-filter__action-buttons'\" *ngIf=\"!isInstantFiltering\">\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableFilterButton$ | async\"\n      (click)=\"clickFilter()\"\n      [color]=\"'primary'\"\n      [data-test-id]=\"testId + '-submit-button'\"\n    >\n      {{ \"i18n.qd.container.toolbar.filter.filter\" | translate }}\n    </button>\n\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableResetButton$ | async\"\n      (click)=\"resetFilter()\"\n      [color]=\"'secondary'\"\n      [data-test-id]=\"testId + '-reset-button'\"\n    >\n      {{\n        ((hasPreselection$ | async)\n          ? \"i18n.qd.container.toolbar.filter.backToPreSelect\"\n          : \"i18n.qd.container.toolbar.filter.reset\"\n        ) | translate\n      }}\n    </button>\n  </div>\n</ng-container>\n", styles: [":host{position:relative;display:flex;flex-wrap:wrap}:host .qd-filter__action-buttons{display:flex;flex-wrap:wrap-reverse}:host ::ng-deep .qd-button{position:relative;margin-bottom:1rem}:host ::ng-deep .qd-button:last-child{margin-left:1rem}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdFilterService }, { type: i2.QdFilterRouterConnectorService }, { type: i3.QdDependentFiltersService }], propDecorators: { filterData: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], queryStringOutput: [{
+                type: Output
+            }], postBodyOutput: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], filterCategory: [{
+                type: ViewChildren,
+                args: [forwardRef(() => QdFilterCategoryComponent)]
+            }], dataTestId: [{
+                type: HostBinding,
+                args: ['attr.data-test-id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.component.js","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/filter/filter.component.ts","../../../../../libs/qd-ui/src/lib/filter/filter.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  forwardRef,\n  HostBinding,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  SimpleChanges,\n  ViewChildren\n} from '@angular/core';\nimport { diff } from 'deep-object-diff';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  delay,\n  firstValueFrom,\n  from,\n  merge,\n  Observable,\n  ReplaySubject,\n  Subscription,\n  switchMap,\n  tap\n} from 'rxjs';\nimport { distinctUntilChanged, filter, map, skip, take } from 'rxjs/operators';\nimport { v4 as uuid } from 'uuid';\nimport * as _ from 'lodash';\nimport { QdFilterCategoryComponent } from './category/filter-category.component';\nimport { QdFilterService } from './filter-service/filter.service';\nimport { hasActiveCategory } from './helpers/filter-active.helper';\nimport { QdFilterCategory, QdFilterConfigData } from './model/filter-config.interface';\nimport { QdFilterPostBodyData } from './model/filter-post-body.interface';\nimport { QdFilterRouterConnectorService } from './services/filter-router-connector.service';\nimport { QdDependentFiltersService } from './services/dependent-filters.service';\n\n/**\n * The **QdFilter** is responsible for the filtering of data.\n *\n * Hirarchical structure::\n * - **Filter**: Name of the component.\n * - **Categories**: A list of one or more different categories.\n * - **Items**: A list with one or more items belongs to a parent category.\n *\n * ### Filter selection ###\n *\n * To get the applied filters you can listen to the outputs `(queryStringOutput)` and `(postBodyOutput)`.\n * These outputs will be emitted when the filter is triggered. The `(queryStringOutput)` returns\n * the applied filters as an url string with an encoded *filter* parameter. The `(postBodyOutput)`\n * yields an object containing the categories and active items.\n *\n * In addition to the outputs, you also can query the current filter selection with the\n * filter component methods `getCurrentQueryString`, `getCurrentFilterUrlParameterString` and `getCurrentPostBody`.\n *\n * ### Preserve filter state ###\n *\n * To preserve the filter state when navigating, for example between detail and overview page, you just have to define\n * a uid in the filter data config.\n *\n * ### Multi Staging Filters\n *\n * To build a dependency chain of filters you can use the `dependsOn` property of a filter that depends on\n * other filters. In the `dependsOn` property you set the names of the filter categories the category depends on.\n * Always when one of these categories change the `itemsResolver` will be called with the list\n * of categories given in `dependsOn`. The `itemsResolver` can also be defined in the config where `dependsOn`\n * is also defined.\n *\n * If the items resolver has not been called yet or when it returns an empty array of items,\n * the corresponding filter stage won't be rendered.\n *\n * #### Support\n *\n * Multi Staging Filters only work for `singleSelect` and `multiSelect` filters.\n *\n */\n@Component({\n  selector: 'qd-filter',\n  templateUrl: './filter.component.html',\n  styleUrls: ['./filter.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { class: 'qd-filter' },\n  providers: [QdDependentFiltersService]\n})\nexport class QdFilterComponent implements OnInit, OnChanges, OnDestroy {\n  /**\n   * The configuration of the filter\n   */\n  @Input() set filterData(filterData: QdFilterConfigData) {\n    this._filterDataSubject.next(filterData);\n  }\n\n  get filterData(): QdFilterConfigData {\n    return this._filterDataSubject.value;\n  }\n\n  /**\n   * A static test ID for integration tests can be set. <br />\n   * The value for the HTML attribute [data-test-id].\n   */\n  @Input('data-test-id') testId = 'filter';\n\n  /**\n   * Emits event on click/tap of the filter/reset button of the filter or on deletion of an active item. <br />\n   * Return value is the query string of the filter.\n   */\n  @Output() queryStringOutput = new EventEmitter<string>();\n\n  /**\n   * Emits event on click/tap of the filter/reset button of the filter or on deletion of an active item. <br />\n   * Return value is the result object of the filter.\n   */\n  @Output() postBodyOutput = new EventEmitter<QdFilterPostBodyData>();\n\n  /**\n   * Emits event when the values of the filter change. Return value matches the current object of the filter.\n   */\n  @Output() valueChange = new EventEmitter<QdFilterPostBodyData>();\n\n  @ViewChildren(forwardRef(() => QdFilterCategoryComponent))\n  public filterCategory: QueryList<QdFilterCategoryComponent>;\n\n  @HostBinding('attr.data-test-id') get dataTestId(): string {\n    return this.testId + '-' + this.filterId;\n  }\n\n  disableFilterButton$: Observable<boolean>;\n  disableResetButton$: Observable<boolean>;\n  filterId: string;\n\n  private _queryStringSubscription: Subscription;\n  private _postBodySubscription: Subscription;\n  private _emitOutputsSubscription: Subscription;\n  private _filterValueSubscription: Subscription;\n  private _filterDataSubject = new BehaviorSubject<QdFilterConfigData>(undefined);\n  private _hasPreselectionSubject = new ReplaySubject<boolean>(1);\n  private _categoriesSubject = new ReplaySubject<QdFilterCategory['category'][]>(1);\n  private _filterConnectedWithRouterSubject = new ReplaySubject<void>();\n  private _filterConnectedWithRouter$ = this._filterConnectedWithRouterSubject.asObservable();\n\n  set hasPreselection(hasPreselection: boolean) {\n    this._hasPreselectionSubject.next(hasPreselection);\n  }\n\n  get hasPreselection$(): Observable<boolean> {\n    return this._hasPreselectionSubject.asObservable();\n  }\n\n  set categories(categories: QdFilterCategory['category'][]) {\n    this._categoriesSubject.next(categories);\n  }\n\n  get categories$(): Observable<QdFilterCategory['category'][]> {\n    return this._categoriesSubject.asObservable();\n  }\n\n  get isInstantFiltering(): boolean {\n    return this.filterData?.isInstantFiltering === true;\n  }\n\n  constructor(\n    readonly filterService: QdFilterService,\n    readonly filterRouterConnectorService: QdFilterRouterConnectorService,\n    readonly dependentFiltersService: QdDependentFiltersService\n  ) {}\n\n  async ngOnInit(): Promise<void> {\n    await this.waitForFilterData();\n\n    this.filterId = this.filterData?.uid || uuid();\n\n    this.validateConfig();\n    this.init();\n  }\n\n  private waitForFilterData(): Promise<QdFilterConfigData> {\n    return firstValueFrom(this._filterDataSubject.pipe(filter(filterData => !!filterData)));\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // TODO: Decision: Is there really a need for this???\n    if (this.hasChangesByKey(changes, 'i18n'))\n      this.filterService.updateCategoryTranslation(this.filterId, this.filterData);\n\n    if (this.hasChangesByKey(changes, 'items') || this.hasChangesByKey(changes, 'filter'))\n      this.filterService.initFilterState(this.filterId, this.filterData);\n\n    if (this.hasChangesByCategoriesLength(changes)) {\n      this.filterService.initFilterState(this.filterId, this.filterData);\n      this.categories = this.filterData.categories.map(category => category.category);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.filterRouterConnectorService.disconnectFilterFromRouter(this);\n    this.dependentFiltersService.destroy();\n\n    this._queryStringSubscription?.unsubscribe();\n    this._postBodySubscription?.unsubscribe();\n    this._emitOutputsSubscription?.unsubscribe();\n    this._filterValueSubscription?.unsubscribe();\n\n    /* the ReplaySubjects would cause an initial emission of the outputs if the component is reinitialized\n     * (when navigating back for example). ReplaySubjects are used here because the subscription of the section\n     * is delayed in the integrated solution with the qdConnectToFilter directive. */\n    this.filterService.resetEmissionReplaySubjects(this.filterId);\n  }\n\n  clickFilter(): void {\n    this.filterCategory.forEach(category => category.refreshItems());\n\n    this.emitOutputs();\n  }\n\n  async resetFilter(): Promise<void> {\n    this.filterService.initFilterState(this.filterId, this.filterData);\n    this.filterCategory.forEach(category => category.handleReset());\n\n    if (await firstValueFrom(this.hasPreselection$)) this.emitOutputs();\n  }\n\n  emitOutputs(): void {\n    this.filterService.emitQueryString(this.filterId, this.filterData?.outputLegacyQueryStringFormat !== false);\n    this.filterService.emitFilterUrlParameterString(this.filterId);\n    this.filterService.emitPostBody(this.filterId);\n  }\n\n  getCurrentQueryString(): Observable<string> {\n    return this.filterService.getCurrentQueryString(\n      this.filterId,\n      this.filterData?.outputLegacyQueryStringFormat !== false\n    );\n  }\n\n  getCurrentFilterUrlParameterString(): Observable<string> {\n    return this.filterService.getCurrentFilterUrlParameterString(this.filterId);\n  }\n\n  getCurrentPostBody(): Observable<QdFilterPostBodyData> {\n    return this.filterService.getCurrentPostBody(this.filterId);\n  }\n\n  hasFilterData(): boolean {\n    return this.filterData !== undefined;\n  }\n\n  setFilterConfig(filterData: QdFilterConfigData): void {\n    this._filterDataSubject.next(filterData);\n  }\n\n  updateFilterConfig(filterData: QdFilterConfigData): void {\n    this._filterDataSubject.next(filterData);\n\n    this.filterService.initFilterState(this.filterId, this.filterData);\n    this.filterService.emitPostBody(this.filterId);\n    this.filterService.emitFilterUrlParameterString(this.filterId);\n  }\n\n  getFilterChanges$(): Observable<QdFilterPostBodyData> {\n    return from(this.waitForFilterData()).pipe(\n      // wait for filterId\n      switchMap(() => this._filterConnectedWithRouter$),\n      delay(1),\n      switchMap(() => this.filterService.getPostBody$(this.filterId))\n    );\n  }\n\n  private validateConfig(): void {\n    if (this.filterData?.outputLegacyQueryStringFormat !== false && this.queryStringOutput.observers.length > 0) {\n      console.warn(\n        'QdFilter | You use the queryStringOutput with the legacy format. To use the new format please set outputLegacyQueryStringFormat to false. The legacy format will be removed in future releases.'\n      );\n    }\n  }\n\n  private init(): void {\n    this.reInitFromStoreIfReMounted();\n\n    this.disableFilterButton$ = this.filterService\n      .selectHasActiveCategory$(this.filterId)\n      .pipe(map(hasActive => !hasActive));\n\n    this.initResetButtonActivation();\n\n    this._queryStringSubscription = this.filterService\n      .getQueryString$(this.filterId)\n      .subscribe(queryString => this.queryStringOutput.emit(queryString));\n\n    this._postBodySubscription = this.filterService\n      .getPostBody$(this.filterId)\n      .subscribe(postBody => this.postBodyOutput.emit(postBody));\n\n    this.hasPreselection = hasActiveCategory(this.filterData?.categories);\n\n    this._emitOutputsSubscription = merge(\n      this.hasPreselectionAfterRouterConnection$.pipe(\n        filter(hasPreselection => hasPreselection || this.filterData?.emitOutputsInitially)\n      ),\n      this.allFiltersRemoved$\n    ).subscribe(() => {\n      this.emitOutputs();\n    });\n\n    this._filterValueSubscription = this.filterService\n      .getCurrentPostBody(this.filterId)\n      .pipe(\n        distinctUntilChanged(_.isEqual),\n        tap(() => {\n          if (this.isInstantFiltering) this.emitOutputs();\n        })\n      )\n      .subscribe(filterValue => this.valueChange.emit(filterValue));\n\n    this.initializeDependentFiltersService();\n  }\n\n  private initializeDependentFiltersService(): void {\n    this.dependentFiltersService.initialize(this);\n\n    this._filterDataSubject\n      .pipe(skip(1)) // skip current value, only reinitialize for changes\n      .subscribe(() => this.dependentFiltersService.reinitialize());\n  }\n\n  private initResetButtonActivation(): void {\n    this.disableResetButton$ = combineLatest([\n      this.filterService.selectHasActiveCategory$(this.filterId),\n      this.filterService\n        .selectFilterDataById$(this.filterId)\n        .pipe(\n          map(data =>\n            data.map(entry => entry.items).map(items => items.map(item => item).map(item => _.omit(item, ['hidden'])))\n          )\n        ),\n      this.hasPreselection$\n    ]).pipe(\n      map(([hasActiveCategory, items, hasPreselection]) => {\n        if (hasPreselection) {\n          const categories = _.flatten(\n            this.filterData.categories.map(category => category.items.map(item => ({ active: false, ...item })))\n          ).filter(category => category.item);\n\n          return _.isEqual(\n            _.flatten(items).filter(item => item.item),\n            categories\n          );\n        }\n\n        return !hasActiveCategory;\n      })\n    );\n  }\n\n  private get hasPreselectionAfterRouterConnection$(): Observable<boolean> {\n    return this.filterRouterConnectorService.connectFilterWithRouter(this).pipe(\n      tap(() => this._filterConnectedWithRouterSubject.next()),\n      switchMap(() => this.filterService.selectHasActiveCategory$(this.filterId)),\n      take(1)\n    );\n  }\n\n  private get allFiltersRemoved$(): Observable<boolean> {\n    return this.filterService.selectHasActiveCategory$(this.filterId).pipe(\n      skip(1),\n      filter(someCategoryActive => !someCategoryActive)\n    );\n  }\n\n  private hasChangesByKey(changes, key): boolean {\n    const _diff = diff(changes.filterData.currentValue, changes.filterData.previousValue) as QdFilterConfigData;\n\n    if (!_diff || !_diff.categories) return false;\n\n    return Object.values(_diff.categories)?.filter(category => category && category[key] !== undefined).length > 0;\n  }\n\n  private hasChangesByCategoriesLength(changes): boolean {\n    if (changes.filterData.previousValue === undefined) return false;\n\n    return changes.filterData.currentValue.categories.length !== changes.filterData.previousValue.categories.length;\n  }\n\n  private reInitFromStoreIfReMounted(): void {\n    this.filterService\n      .selectFilterDataById$(this.filterId)\n      .pipe(take(1))\n      .subscribe(filterCategoriesFromStore => {\n        if (filterCategoriesFromStore.length > 0) {\n          this.categories = filterCategoriesFromStore.map(category => category.category);\n        } else {\n          this.categories = this.filterData?.categories.map(category => category.category);\n          this.filterService.initFilterState(this.filterId, this.filterData);\n        }\n      });\n  }\n}\n","<ng-container *ngIf=\"(categories$ | async)?.length > 0\">\n  <ng-container\n    *ngFor=\"let category of categories$ | async; let last = last; let length = count; let categoryIndex = index\"\n  >\n    <qd-filter-category\n      [filterId]=\"filterId\"\n      [isInstantFiltering]=\"isInstantFiltering\"\n      [categoryIndex]=\"categoryIndex\"\n      [lastCategory]=\"last\"\n      [data-test-id]=\"testId + '-category-' + categoryIndex + '-' + category\"\n    ></qd-filter-category>\n  </ng-container>\n\n  <div [class]=\"'qd-filter__action-buttons'\" *ngIf=\"!isInstantFiltering\">\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableFilterButton$ | async\"\n      (click)=\"clickFilter()\"\n      [color]=\"'primary'\"\n      [data-test-id]=\"testId + '-submit-button'\"\n    >\n      {{ \"i18n.qd.container.toolbar.filter.filter\" | translate }}\n    </button>\n\n    <button\n      qdButton\n      qdButtonLink\n      [disabled]=\"disableResetButton$ | async\"\n      (click)=\"resetFilter()\"\n      [color]=\"'secondary'\"\n      [data-test-id]=\"testId + '-reset-button'\"\n    >\n      {{\n        ((hasPreselection$ | async)\n          ? \"i18n.qd.container.toolbar.filter.backToPreSelect\"\n          : \"i18n.qd.container.toolbar.filter.reset\"\n        ) | translate\n      }}\n    </button>\n  </div>\n</ng-container>\n"]}