@firestitch/filter 15.0.1 → 16.0.0

package/esm2022/app/services/external-params/persistance-params-controller.service.mjs

@@ -0,0 +1,62 @@
+import { Location } from '@angular/common';
+import { Injectable, Optional } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { MatDialogRef } from '@angular/material/dialog';
+import { getNormalizedPath } from '@firestitch/common';
+import { DrawerRef } from '@firestitch/drawer';
+import { FsPersistanceStore, FsStore } from '@firestitch/store';
+import { restoreItems } from '../../helpers/restore-items';
+import { FsFilterItemsStore } from '../items-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@firestitch/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+import * as i4 from "../items-store.service";
+import * as i5 from "@angular/material/dialog";
+import * as i6 from "@firestitch/drawer";
+const FILTER_STORE_KEY = 'fs-filter-persist';
+export class PersistanceParamsController extends FsPersistanceStore {
+    _location;
+    _itemsStore;
+    _dialogRef;
+    _drawerRef;
+    STORE_KEY = FILTER_STORE_KEY;
+    _paramsCase;
+    constructor(_store, _route, _location, _itemsStore, _dialogRef, _drawerRef) {
+        super(_store, _route);
+        this._location = _location;
+        this._itemsStore = _itemsStore;
+        this._dialogRef = _dialogRef;
+        this._drawerRef = _drawerRef;
+    }
+    init(persistanceConfig, namespace, paramsCase) {
+        this._paramsCase = paramsCase;
+        namespace = namespace ?? getNormalizedPath(this._location);
+        const persistanceDisabled = !!this._dialogRef || !!this._drawerRef;
+        this.setConfig(persistanceConfig, namespace, persistanceDisabled);
+    }
+    restore() {
+        if (!this.enabled) {
+            return;
+        }
+        super.restore();
+        const items = [
+            ...this._itemsStore.items,
+            this._itemsStore.sortByItem,
+            this._itemsStore.sortDirectionItem,
+        ].filter((item) => !!item);
+        if (this._value) {
+            this._value.data = restoreItems(this._value.data, items);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceParamsController, deps: [{ token: i1.FsStore }, { token: i2.ActivatedRoute }, { token: i3.Location }, { token: i4.FsFilterItemsStore }, { token: i5.MatDialogRef, optional: true }, { token: i6.DrawerRef, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceParamsController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PersistanceParamsController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FsStore }, { type: i2.ActivatedRoute }, { type: i3.Location }, { type: i4.FsFilterItemsStore }, { type: i5.MatDialogRef, decorators: [{
+                    type: Optional
+                }] }, { type: i6.DrawerRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/services/external-params/query-params-controller.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { restoreItems } from '../../helpers/restore-items';
+import { FsFilterItemsStore } from '../items-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../items-store.service";
+export class QueryParamsController {
+    _route;
+    _itemsStore;
+    _enabled = false;
+    _paramsCase;
+    _fetchedParams;
+    constructor(_route, _itemsStore) {
+        this._route = _route;
+        this._itemsStore = _itemsStore;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    get fetchedParams() {
+        return this._fetchedParams;
+    }
+    init(enabled, paramsCase) {
+        this._enabled = enabled;
+        this._paramsCase = paramsCase;
+        if (this.enabled) {
+            this.fetchFromQueryParams();
+        }
+    }
+    writeStateToQueryParams(params) {
+        if (this._enabled) {
+            this._replaceState(params);
+        }
+    }
+    /**
+     * Parse query and update filter values
+     */
+    fetchFromQueryParams() {
+        const items = [
+            ...this._itemsStore.items,
+            this._itemsStore.sortByItem,
+            this._itemsStore.sortDirectionItem,
+        ].filter((item) => !!item);
+        this._fetchedParams = restoreItems(this._route.snapshot.queryParams, items);
+    }
+    _replaceState(data) {
+        const url = new URL(window.location.href);
+        Object.keys(data)
+            .forEach((name) => {
+            if (data[name] === undefined || data[name] === null) {
+                url.searchParams.delete(name);
+            }
+            else {
+                url.searchParams.set(name, data[name]);
+            }
+        });
+        history.replaceState({}, null, url.pathname + url.search);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QueryParamsController, deps: [{ token: i1.ActivatedRoute }, { token: i2.FsFilterItemsStore }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QueryParamsController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QueryParamsController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i2.FsFilterItemsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/services/external-params/saved-filters-controller.service.mjs

@@ -0,0 +1,167 @@
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { distinctUntilChanged, take, takeUntil, tap, } from 'rxjs/operators';
+import { FsFilterSavedFilterEditComponent, } from '../../components/saved-filter/saved-filter-edit/saved-filter-edit.component';
+import { buildQueryParams } from '../../helpers/build-query-params';
+import { restoreItems } from '../../helpers/restore-items';
+import { FsFilterItemsStore } from '../items-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../items-store.service";
+import * as i2 from "@angular/material/dialog";
+export class SavedFiltersController {
+    _itemsStore;
+    _dialog;
+    _config;
+    _savedFilters$ = new BehaviorSubject([]);
+    _activeFilter$ = new BehaviorSubject(null);
+    _enabled$ = new BehaviorSubject(false);
+    _paramsCase;
+    _destroy$ = new Subject();
+    constructor(_itemsStore, _dialog) {
+        this._itemsStore = _itemsStore;
+        this._dialog = _dialog;
+    }
+    get enabled() {
+        return this._enabled$.getValue();
+    }
+    get enabled$() {
+        return this._enabled$
+            .pipe(distinctUntilChanged());
+    }
+    get savedFilters() {
+        return this._savedFilters$.getValue();
+    }
+    set savedFilters(filters) {
+        this._savedFilters$.next(filters);
+    }
+    get savedFilters$() {
+        return this._savedFilters$
+            .pipe(distinctUntilChanged());
+    }
+    get activeFilter() {
+        return this._activeFilter$.getValue();
+    }
+    get activeFilter$() {
+        return this._activeFilter$
+            .pipe(distinctUntilChanged());
+    }
+    get activeFilterData() {
+        return this._activeFilter$.getValue()?.filters;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    init(remoteParamsConfig, paramsCase) {
+        if (!remoteParamsConfig) {
+            this._setEnabledStatus(false);
+            return;
+        }
+        this._setEnabledStatus(true);
+        this._paramsCase = paramsCase;
+        this._config = remoteParamsConfig;
+    }
+    initSavedFilters(filters) {
+        filters = [...filters];
+        filters.forEach((savedFilter) => {
+            savedFilter.filters = restoreItems(savedFilter.filters, this._itemsStore.items);
+        });
+        this.savedFilters = filters;
+    }
+    load() {
+        return this._config.load()
+            .pipe(tap((response) => {
+            this.initSavedFilters(response);
+        }));
+    }
+    save(savedFilter) {
+        return this._config.save(savedFilter);
+    }
+    order(savedFilters) {
+        return this._config.order(savedFilters)
+            .pipe(tap(() => {
+            this.savedFilters = [
+                ...savedFilters,
+            ];
+        }));
+    }
+    delete(savedFilter) {
+        return this._config.delete(savedFilter)
+            .pipe(tap(() => {
+            this.savedFilters = this.savedFilters
+                .filter((f) => f.id !== savedFilter.id);
+        }));
+    }
+    setActiveFilter(savedFilter) {
+        if (savedFilter) {
+            const existingFilter = this.savedFilters
+                .find((f) => f.id === savedFilter.id);
+            if (!existingFilter) {
+                throw new Error(`Saved filter cannot be activated, because it does not exists. Filter ID = ${savedFilter.id}`);
+            }
+            this._activeFilter$.next(existingFilter);
+        }
+        else {
+            this._activeFilter$.next(null);
+        }
+    }
+    openSavedFilterEditDialog() {
+        const params = buildQueryParams(this._itemsStore.valuesAsQuery(), this._itemsStore.items);
+        const dialogConfig = {
+            data: {
+                params: params,
+                savedFilters: this.savedFilters,
+                saveCallback: this.save.bind(this),
+            },
+        };
+        this._dialog
+            .open(FsFilterSavedFilterEditComponent, dialogConfig)
+            .beforeClosed()
+            .pipe(take(1), takeUntil(this._destroy$))
+            .subscribe((updatedFilter) => {
+            if (updatedFilter) {
+                // get already saved related filter object
+                const savedFilter = this.savedFilters
+                    .find((f) => f.id === updatedFilter.id);
+                // restore values from query string
+                updatedFilter.filters = restoreItems(updatedFilter.filters, this._itemsStore.items);
+                if (savedFilter) {
+                    Object.assign(savedFilter, updatedFilter);
+                }
+                else {
+                    this.resetActiveFilter();
+                    this.savedFilters = [
+                        ...this.savedFilters,
+                        updatedFilter,
+                    ];
+                }
+                this.updateActiveFilter();
+            }
+        });
+    }
+    updateActiveFilter() {
+        // Lookup active filter
+        const acitveFilter = this.savedFilters
+            .find((f) => f.active);
+        if (acitveFilter) {
+            this.setActiveFilter(acitveFilter);
+        }
+    }
+    resetActiveFilter() {
+        // Reset all previously activated filters
+        this.savedFilters.forEach((savedFilter) => {
+            savedFilter.active = false;
+        });
+        this.setActiveFilter(null);
+    }
+    _setEnabledStatus(value) {
+        this._enabled$.next(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SavedFiltersController, deps: [{ token: i1.FsFilterItemsStore }, { token: i2.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SavedFiltersController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SavedFiltersController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FsFilterItemsStore }, { type: i2.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"saved-filters-controller.service.js","sourceRoot":"","sources":["../../../../../src/app/services/external-params/saved-filters-controller.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\n\nimport { MatDialog } from '@angular/material/dialog';\n\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport {\n  distinctUntilChanged,\n  take,\n  takeUntil,\n  tap,\n} from 'rxjs/operators';\n\nimport {\n  FsFilterSavedFilterEditComponent,\n} from '../../components/saved-filter/saved-filter-edit/saved-filter-edit.component';\nimport { buildQueryParams } from '../../helpers/build-query-params';\nimport { restoreItems } from '../../helpers/restore-items';\nimport { IFilterExternalParams } from '../../interfaces/external-params.interface';\nimport {\n  IFilterSavedFilter,\n  IFilterSavedFiltersConfig,\n} from '../../interfaces/saved-filters.interface';\nimport { FsFilterItemsStore } from '../items-store.service';\n\n\n@Injectable()\nexport class SavedFiltersController implements OnDestroy {\n\n  protected _config: IFilterSavedFiltersConfig;\n\n  private _savedFilters$ = new BehaviorSubject<IFilterSavedFilter[]>([]);\n  private _activeFilter$ = new BehaviorSubject<IFilterSavedFilter>(null);\n  private _enabled$ = new BehaviorSubject<boolean>(false);\n  private _paramsCase: 'snake' | 'camel';\n  private _destroy$ = new Subject<void>();\n\n  constructor(\n    private _itemsStore: FsFilterItemsStore,\n    private _dialog: MatDialog,\n  ) {}\n\n  public get enabled(): boolean {\n    return this._enabled$.getValue();\n  }\n\n  public get enabled$(): Observable<boolean> {\n    return this._enabled$\n      .pipe(\n        distinctUntilChanged(),\n      );\n  }\n\n  public get savedFilters(): IFilterSavedFilter[] {\n    return this._savedFilters$.getValue();\n  }\n\n  public set savedFilters(filters: IFilterSavedFilter[]) {\n    this._savedFilters$.next(filters);\n  }\n\n  public get savedFilters$(): Observable<IFilterSavedFilter[]> {\n    return this._savedFilters$\n      .pipe(\n        distinctUntilChanged(),\n      );\n  }\n\n  public get activeFilter(): IFilterSavedFilter {\n    return this._activeFilter$.getValue();\n  }\n\n  public get activeFilter$(): Observable<IFilterSavedFilter> {\n    return this._activeFilter$\n      .pipe(\n        distinctUntilChanged(),\n      );\n  }\n\n  public get activeFilterData(): IFilterExternalParams {\n    return this._activeFilter$.getValue()?.filters;\n  }\n\n  public ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  public init(\n    remoteParamsConfig: IFilterSavedFiltersConfig,\n    paramsCase: 'snake' | 'camel',\n  ): void {\n    if (!remoteParamsConfig) {\n      this._setEnabledStatus(false);\n\n      return;\n    }\n    this._setEnabledStatus(true);\n\n    this._paramsCase = paramsCase;\n    this._config = remoteParamsConfig;\n  }\n\n  public initSavedFilters(filters: IFilterSavedFilter[]): void {\n    filters = [...filters];\n    filters.forEach((savedFilter) => {\n      savedFilter.filters = restoreItems(\n        savedFilter.filters,\n        this._itemsStore.items,\n      );\n    });\n\n    this.savedFilters = filters;\n  }\n\n  public load(): Observable<IFilterSavedFilter[]> {\n    return this._config.load()\n      .pipe(\n        tap((response) => {\n          this.initSavedFilters(response);\n        }),\n      );\n  }\n\n  public save(savedFilter: IFilterSavedFilter): Observable<IFilterSavedFilter> {\n    return this._config.save(savedFilter);\n  }\n\n  public order(savedFilters: IFilterSavedFilter[]): Observable<IFilterSavedFilter[]> {\n    return this._config.order(savedFilters)\n      .pipe(\n        tap(() => {\n          this.savedFilters = [\n            ...savedFilters,\n          ];\n        }),\n      );\n  }\n\n  public delete(savedFilter: IFilterSavedFilter): Observable<IFilterSavedFilter> {\n    return this._config.delete(savedFilter)\n      .pipe(\n        tap(() => {\n          this.savedFilters = this.savedFilters\n            .filter((f) => f.id !== savedFilter.id);\n        }),\n      );\n  }\n\n  public setActiveFilter(savedFilter: IFilterSavedFilter): void {\n    if (savedFilter) {\n      const existingFilter = this.savedFilters\n        .find((f) => f.id === savedFilter.id);\n\n      if (!existingFilter) {\n        throw new Error(`Saved filter cannot be activated, because it does not exists. Filter ID = ${savedFilter.id}`);\n      }\n\n      this._activeFilter$.next(existingFilter);\n    } else {\n      this._activeFilter$.next(null);\n    }\n  }\n\n  public openSavedFilterEditDialog(): void {\n    const params = buildQueryParams(\n      this._itemsStore.valuesAsQuery(),\n      this._itemsStore.items,\n    );\n\n    const dialogConfig = {\n      data: {\n        params: params,\n        savedFilters: this.savedFilters,\n        saveCallback: this.save.bind(this),\n      },\n    };\n\n    this._dialog\n      .open(FsFilterSavedFilterEditComponent, dialogConfig)\n      .beforeClosed()\n      .pipe(\n        take(1),\n        takeUntil(this._destroy$),\n      )\n      .subscribe((updatedFilter: IFilterSavedFilter | null) => {\n        if (updatedFilter) {\n          // get already saved related filter object\n          const savedFilter = this.savedFilters\n            .find((f) => f.id === updatedFilter.id);\n\n          // restore values from query string\n          updatedFilter.filters = restoreItems(\n            updatedFilter.filters,\n            this._itemsStore.items,\n          );\n\n\n          if (savedFilter) {\n            Object.assign(savedFilter, updatedFilter);\n          } else {\n            this.resetActiveFilter();\n            this.savedFilters = [\n              ...this.savedFilters,\n              updatedFilter,\n            ];\n          }\n\n          this.updateActiveFilter();\n        }\n      });\n  }\n\n  public updateActiveFilter(): void {\n    // Lookup active filter\n    const acitveFilter = this.savedFilters\n      .find((f) => f.active);\n\n    if (acitveFilter) {\n      this.setActiveFilter(acitveFilter);\n    }\n  }\n\n  public resetActiveFilter(): void {\n    // Reset all previously activated filters\n    this.savedFilters.forEach((savedFilter) => {\n      savedFilter.active = false;\n    });\n\n    this.setActiveFilter(null);\n  }\n\n  private _setEnabledStatus(value: boolean): void {\n    this._enabled$.next(value);\n  }\n}\n"]}

package/esm2022/app/services/external-params-controller.service.mjs

@@ -0,0 +1,185 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { filter, switchMap, take, takeUntil } from 'rxjs/operators';
+import { buildQueryParams } from '../helpers/build-query-params';
+import { PersistanceParamsController } from './external-params/persistance-params-controller.service';
+import { QueryParamsController } from './external-params/query-params-controller.service';
+import { SavedFiltersController } from './external-params/saved-filters-controller.service';
+import { FsFilterItemsStore } from './items-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./items-store.service";
+import * as i2 from "./external-params/persistance-params-controller.service";
+import * as i3 from "./external-params/query-params-controller.service";
+import * as i4 from "./external-params/saved-filters-controller.service";
+export class ExternalParamsController {
+    _itemsStore;
+    _persistanceStore;
+    _queryParams;
+    _savedFilters;
+    _init;
+    _pending$ = new BehaviorSubject(false);
+    _shouldResetSavedFilters = true;
+    _config;
+    _destroy$ = new Subject();
+    constructor(_itemsStore, _persistanceStore, _queryParams, _savedFilters) {
+        this._itemsStore = _itemsStore;
+        this._persistanceStore = _persistanceStore;
+        this._queryParams = _queryParams;
+        this._savedFilters = _savedFilters;
+    }
+    get params() {
+        let result = {};
+        if (this._persistanceStore.enabled) {
+            result = {
+                ...result,
+                ...this._persistanceStore.value?.data,
+            };
+        }
+        if (this._savedFilters.enabled && this._savedFilters.activeFilter) {
+            const query = Object.keys(result)
+                .filter((key) => !this._itemsStore.itemNames.includes(key))
+                .reduce((acc, key) => {
+                return {
+                    ...acc,
+                    [key]: result[key],
+                };
+            }, {});
+            result = {
+                ...query,
+                ...this._savedFilters.activeFilterData,
+            };
+        }
+        else if (this._queryParams.enabled) {
+            result = {
+                ...result,
+                ...this._queryParams.fetchedParams,
+            };
+        }
+        return result;
+    }
+    get pending() {
+        return this._pending$.getValue();
+    }
+    get pending$() {
+        return this._pending$.asObservable();
+    }
+    get savedFiltersController() {
+        return this._savedFilters;
+    }
+    get savedFiltersEnabled() {
+        return this._savedFilters.enabled;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    setConfig(config) {
+        this._config = config;
+        this._initPersistance();
+        this._initQueryParams();
+        this._initSavedFilters();
+        this.initItems();
+    }
+    setActiveSavedFilter(savedFilter) {
+        this.savedFiltersController.setActiveFilter(savedFilter);
+        if (savedFilter) {
+            this.reloadFiltersWithValues(savedFilter.filters, false);
+        }
+    }
+    reloadFiltersWithValues(params, shouldResetSavedFilters = true) {
+        this._shouldResetSavedFilters = shouldResetSavedFilters;
+        this._itemsStore.updateItemsWithValues(params);
+        this._saveQueryParams();
+        this._savePersistedParams();
+    }
+    initItems() {
+        this._pending$.next(true);
+        if (this._savedFilters.enabled) {
+            this._savedFilters
+                .load()
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(() => {
+                this._savedFilters.updateActiveFilter();
+                this._initItemsValues();
+                this._listenAndResetSavedFilters();
+                this._pending$.next(false);
+            });
+        }
+        else {
+            this._initItemsValues();
+            this._pending$.next(false);
+        }
+        this._listenItemsChange();
+    }
+    _initItemsValues() {
+        this._itemsStore.init(this.params);
+        this._saveQueryParams();
+        this._savePersistedParams();
+    }
+    fetchQueryParams() {
+        this._initQueryParams();
+        this._itemsStore.updateItemsWithValues(this.params);
+    }
+    _initPersistance() {
+        this._persistanceStore.init(this._config.persist, this._config.namespace, this._config.case);
+    }
+    _initQueryParams() {
+        this._queryParams.init(this._config.queryParam, this._config.case);
+    }
+    _initSavedFilters() {
+        this._savedFilters.init(this._config.savedFilters, this._config.case);
+    }
+    _listenItemsChange() {
+        this._itemsStore.ready$
+            .pipe(filter((v) => v), take(1), takeUntil(this._destroy$))
+            .subscribe(() => {
+            this._saveQueryParams();
+            this._savePersistedParams();
+        });
+        this._itemsStore
+            .itemsChange$
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this._saveQueryParams();
+            this._savePersistedParams();
+        });
+    }
+    _listenAndResetSavedFilters() {
+        this._itemsStore
+            .itemsChange$
+            .pipe(filter(() => !!this.savedFiltersController.activeFilter), switchMap(() => {
+            const shouldReset = this._shouldResetSavedFilters;
+            this._shouldResetSavedFilters = true;
+            return of(shouldReset);
+        }), filter((shouldReset) => shouldReset), takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.savedFiltersController.resetActiveFilter();
+        });
+    }
+    _saveQueryParams() {
+        const targetItems = this._itemsStore.items
+            .filter((item) => !item.queryParamsDisabled);
+        const params = buildQueryParams(this._itemsStore.valuesAsQuery({
+            onlyPresented: false,
+            items: targetItems,
+            persisted: true,
+        }), targetItems);
+        this._queryParams.writeStateToQueryParams(params);
+    }
+    _savePersistedParams() {
+        const targetItems = this._itemsStore.items
+            .filter((item) => !item.persistanceDisabled);
+        const params = buildQueryParams(this._itemsStore.valuesAsQuery({
+            onlyPresented: false,
+            items: targetItems,
+            persisted: true,
+        }), targetItems);
+        this._persistanceStore.save(params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ExternalParamsController, deps: [{ token: i1.FsFilterItemsStore }, { token: i2.PersistanceParamsController }, { token: i3.QueryParamsController }, { token: i4.SavedFiltersController }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ExternalParamsController });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ExternalParamsController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FsFilterItemsStore }, { type: i2.PersistanceParamsController }, { type: i3.QueryParamsController }, { type: i4.SavedFiltersController }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"external-params-controller.service.js","sourceRoot":"","sources":["../../../../src/app/services/external-params-controller.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\n\nimport { BehaviorSubject, Observable, of, Subject } from 'rxjs';\nimport { filter, switchMap, take, takeUntil } from 'rxjs/operators';\n\nimport { buildQueryParams } from '../helpers/build-query-params';\nimport { IFilterExternalParams } from '../interfaces/external-params.interface';\nimport { IFilterSavedFilter } from '../interfaces/saved-filters.interface';\nimport { FsFilterConfig } from '../models/filter-config';\n\nimport { PersistanceParamsController } from './external-params/persistance-params-controller.service';\nimport { QueryParamsController } from './external-params/query-params-controller.service';\nimport { SavedFiltersController } from './external-params/saved-filters-controller.service';\nimport { FsFilterItemsStore } from './items-store.service';\n\n\n@Injectable()\nexport class ExternalParamsController implements OnDestroy {\n\n  protected _init;\n\n  private _pending$ = new BehaviorSubject(false);\n  private _shouldResetSavedFilters = true;\n  private _config: FsFilterConfig;\n  private _destroy$ = new Subject<void>();\n\n  constructor(\n    private _itemsStore: FsFilterItemsStore,\n    private _persistanceStore: PersistanceParamsController,\n    private _queryParams: QueryParamsController,\n    private _savedFilters: SavedFiltersController,\n  ) { }\n\n  public get params(): IFilterExternalParams {\n    let result: IFilterExternalParams = {};\n\n    if (this._persistanceStore.enabled) {\n      result = {\n        ...result, \n        ...this._persistanceStore.value?.data,\n      };\n    }\n\n    if (this._savedFilters.enabled && this._savedFilters.activeFilter) {\n      const query = Object.keys(result)\n        .filter((key) => !this._itemsStore.itemNames.includes(key))\n        .reduce((acc, key) => {\n          return {\n            ...acc,\n            [key]: result[key],\n          };\n        }, {});\n\n      result = {\n        ...query, \n        ...this._savedFilters.activeFilterData,\n      };\n    } else if (this._queryParams.enabled) {\n      result = {\n        ...result, \n        ...this._queryParams.fetchedParams,\n      };\n    }\n\n    return result;\n  }\n\n  public get pending(): boolean {\n    return this._pending$.getValue();\n  }\n\n  public get pending$(): Observable<boolean> {\n    return this._pending$.asObservable();\n  }\n\n  public get savedFiltersController(): SavedFiltersController {\n    return this._savedFilters;\n  }\n\n  public get savedFiltersEnabled(): boolean {\n    return this._savedFilters.enabled;\n  }\n\n  public ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  public setConfig(config) {\n    this._config = config;\n\n    this._initPersistance();\n    this._initQueryParams();\n    this._initSavedFilters();\n    this.initItems();\n  }\n\n  public setActiveSavedFilter(savedFilter: IFilterSavedFilter) {\n    this.savedFiltersController.setActiveFilter(savedFilter);\n\n    if (savedFilter) {\n      this.reloadFiltersWithValues(savedFilter.filters, false);\n    }\n  }\n\n  public reloadFiltersWithValues(params: IFilterExternalParams, shouldResetSavedFilters = true) {\n    this._shouldResetSavedFilters = shouldResetSavedFilters;\n    this._itemsStore.updateItemsWithValues(params);\n\n    this._saveQueryParams();\n    this._savePersistedParams();\n  }\n\n  public initItems(): void {\n    this._pending$.next(true);\n    if (this._savedFilters.enabled) {\n      this._savedFilters\n        .load()\n        .pipe(\n          takeUntil(this._destroy$),\n        )\n        .subscribe(() => {\n          this._savedFilters.updateActiveFilter();\n          this._initItemsValues();\n          this._listenAndResetSavedFilters();\n          this._pending$.next(false);\n        });\n    } else {\n      this._initItemsValues();\n      this._pending$.next(false);\n    }\n\n    this._listenItemsChange();\n  }\n\n  public _initItemsValues() {\n    this._itemsStore.init(this.params);\n    this._saveQueryParams();\n    this._savePersistedParams();\n  }\n\n  public fetchQueryParams(): void {\n    this._initQueryParams();\n    this._itemsStore.updateItemsWithValues(this.params);\n  }\n\n  private _initPersistance() {\n    this._persistanceStore.init(\n      this._config.persist,\n      this._config.namespace,\n      this._config.case,\n    );\n  }\n\n  private _initQueryParams() {\n    this._queryParams.init(this._config.queryParam, this._config.case);\n  }\n\n  private _initSavedFilters() {\n    this._savedFilters.init(this._config.savedFilters, this._config.case);\n  }\n\n  private _listenItemsChange() {\n    this._itemsStore.ready$\n      .pipe(\n        filter((v) => v),\n        take(1),\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this._saveQueryParams();\n        this._savePersistedParams();\n      });\n\n    this._itemsStore\n      .itemsChange$\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this._saveQueryParams();\n        this._savePersistedParams();\n      });\n  }\n\n  private _listenAndResetSavedFilters(): void {\n    this._itemsStore\n      .itemsChange$\n      .pipe(\n        filter(() => !!this.savedFiltersController.activeFilter),\n        switchMap(() => {\n          const shouldReset = this._shouldResetSavedFilters;\n\n          this._shouldResetSavedFilters = true;\n\n          return of(shouldReset);\n        }),\n        filter((shouldReset) => shouldReset),\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this.savedFiltersController.resetActiveFilter();\n      });\n  }\n\n  private _saveQueryParams() {\n    const targetItems = this._itemsStore.items\n      .filter((item) => !item.queryParamsDisabled);\n\n    const params = buildQueryParams(\n      this._itemsStore.valuesAsQuery({\n        onlyPresented: false,\n        items: targetItems,\n        persisted: true,\n      }),\n      targetItems,\n    );\n\n    this._queryParams.writeStateToQueryParams(params);\n  }\n\n  private _savePersistedParams() {\n    const targetItems = this._itemsStore.items\n      .filter((item) => !item.persistanceDisabled);\n\n    const params = buildQueryParams(\n      this._itemsStore.valuesAsQuery({\n        onlyPresented: false,\n        items: targetItems,\n        persisted: true,\n      }),\n      targetItems,\n    );\n\n    this._persistanceStore.save(params);\n  }\n}\n"]}