@firestitch/filter 12.13.3 → 13.0.2

package/esm2020/app/services/items-store.service.mjs

@@ -0,0 +1,337 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, forkJoin, Subject } from 'rxjs';
+import { debounceTime, filter, finalize, takeUntil } from 'rxjs/operators';
+import { pickBy } from 'lodash-es';
+import { ItemType } from '../enums/item-type.enum';
+import { createFilterItem } from '../helpers/create-filter-item';
+import { SORT_BY_FIELD, SORT_DIRECTION_FIELD } from '../models/filter-config';
+import { BaseDateRangeItem } from '../models/items/date-range/base-date-range-item';
+import { RangeItem } from '../models/items/range-item';
+import { MultipleSelectItem } from '../models/items/select/multiple-select-item';
+import { SimpleSelectItem } from '../models/items/select/simple-select-item';
+import * as i0 from "@angular/core";
+export class FsFilterItemsStore {
+    constructor() {
+        this.sortByItem = null;
+        this.sortDirectionItem = null;
+        this.keywordItem = null;
+        this._ready$ = new BehaviorSubject(false);
+        this._items = [];
+        this._visibleItems$ = new BehaviorSubject([]);
+        this._itemsByName = new Map();
+        this._itemsValuesLoaded = false;
+        this._hasKeyword = false;
+        this._itemsChange$ = new Subject();
+        this._destroy$ = new Subject();
+        this._lazyInit();
+    }
+    get items() {
+        return this._items;
+    }
+    get visibleItems() {
+        return this._visibleItems$.getValue();
+    }
+    set visibleItems(items) {
+        this._visibleItems$.next(items);
+    }
+    get visibleItems$() {
+        return this._visibleItems$.asObservable();
+    }
+    get hasKeyword() {
+        return this._hasKeyword;
+    }
+    get itemsChange$() {
+        return this._itemsChange$.pipe(debounceTime(30));
+    }
+    get ready$() {
+        return this._ready$.asObservable();
+    }
+    ngOnDestroy() {
+        this.destroyItems();
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    setConfig(config) {
+        this._itemsByName.clear();
+        this._config = config;
+        this.initItems(config.items);
+    }
+    getItemByName(name) {
+        return this._itemsByName.get(name);
+    }
+    initItems(items) {
+        this._itemsValuesLoaded = false;
+        if (Array.isArray(items)) {
+            this._createItems(items);
+        }
+    }
+    filtersClear() {
+        this.items.forEach((item) => {
+            if (item instanceof RangeItem) {
+                item.clearRange(null, item.defaultValue);
+            }
+            else if (item instanceof BaseDateRangeItem) {
+                item.clearDateRange(null, item.defaultValue);
+            }
+            else {
+                item.clear(item.defaultValue);
+            }
+        });
+        if (this.sortByItem) {
+            if (this._config.sort) {
+                this.sortByItem.model = this._config.sort.value;
+            }
+            else {
+                this.sortByItem.clear(this.sortByItem.defaultValue);
+            }
+        }
+        if (this.sortDirectionItem) {
+            if (this._config.sort) {
+                this.sortDirectionItem.model = this._config.sort.direction;
+            }
+            else {
+                this.sortDirectionItem.clear(this.sortDirectionItem.defaultValue);
+            }
+        }
+        this.keywordItem?.clear();
+    }
+    loadAsyncValues() {
+        this.items
+            .filter((item) => item.hasPendingValues)
+            .forEach((item) => item.loadAsyncValues());
+    }
+    loadAsyncDefaults() {
+        // default values can be asynchronous, and we must load them if there is no persisted value instead
+        const defaultValuesToBeLoaded = this.items
+            .filter((item) => {
+            return item.defaultValueFn
+                && (item.persistedValue === null || item.persistedValue === undefined);
+        });
+        // special hack for isolate multiple select
+        // values for this type of select must be preloaded
+        // Read more in class MultipleSelectItem._init()
+        const valuesToBeLoaded = this.items
+            .filter((item) => {
+            return (item instanceof MultipleSelectItem) && item.hasPendingValues && item.isolate;
+        });
+        if (defaultValuesToBeLoaded.length > 0 || valuesToBeLoaded.length > 0) {
+            forkJoin([
+                ...defaultValuesToBeLoaded
+                    .map((item) => item.loadDefaultValue()),
+                ...valuesToBeLoaded
+                    .map((item) => {
+                    item.loadAsyncValues();
+                    return item.loading$
+                        .pipe();
+                }),
+            ])
+                .pipe(finalize(() => {
+                this._ready$.next(true);
+            }), takeUntil(this._destroy$))
+                .subscribe();
+        }
+        else {
+            this._ready$.next(true);
+        }
+    }
+    getSort() {
+        let sortBy = this.getSortByValue();
+        sortBy = sortBy === '__all' ? null : sortBy;
+        let sortDirection = this.getSortDirectionValue();
+        sortDirection = sortDirection === '__all' ? null : sortDirection;
+        return {
+            value: sortBy,
+            direction: sortDirection,
+        };
+    }
+    getSortByValue() {
+        return this.sortByItem ? this.sortByItem.model : null;
+    }
+    getSortDirectionValue() {
+        return this.sortDirectionItem ? this.sortDirectionItem.model : null;
+    }
+    updateSort(sort) {
+        if (sort.sortBy) {
+            this.sortByItem.model = sort.sortBy;
+        }
+        if (sort.sortDirection) {
+            this.sortDirectionItem.model = sort.sortDirection;
+        }
+    }
+    values(onlyPresented = false) {
+        return this.items.reduce((acc, item) => {
+            const value = item.value;
+            if (!onlyPresented || value !== null) {
+                acc[item.name] = value;
+            }
+            return acc;
+        }, {});
+    }
+    valuesAsQuery({ onlyPresented = true, items = null, persisted = false, } = {}) {
+        const params = {};
+        (items || this.items).forEach((filterItem) => {
+            const values = persisted
+                ? filterItem.persistanceObject
+                : filterItem.queryObject;
+            Object.assign(params, values);
+        });
+        if (onlyPresented) {
+            return pickBy(params, (val) => {
+                return val !== void 0;
+            });
+        }
+        return params;
+    }
+    init(p) {
+        this.items
+            .forEach((item) => {
+            item.initValues(p[item.name]);
+        });
+        this._initSortingItems(p);
+        this.loadAsyncDefaults();
+        this._subscribeToItemsChanges();
+    }
+    updateItemsWithValues(values) {
+        this.items
+            .forEach((item) => {
+            if (values[item.name]) {
+                item.model = values[item.name];
+            }
+            else {
+                if (item instanceof RangeItem) {
+                    item.clearRange(null, item.defaultValue);
+                }
+                else if (item instanceof BaseDateRangeItem) {
+                    item.clearDateRange(null, item.defaultValue);
+                }
+                else {
+                    item.clear();
+                }
+            }
+        });
+        if (this.sortByItem) {
+            this.sortByItem.clear();
+        }
+        if (this.sortDirectionItem) {
+            this.sortDirectionItem.clear();
+        }
+    }
+    destroyItems() {
+        this.items
+            .forEach((item) => item.destroy());
+        this.sortByItem?.destroy();
+        this.sortDirectionItem?.destroy();
+        this._items = [];
+        this.sortByItem = null;
+        this.sortDirectionItem = null;
+    }
+    /**
+     * Some items might need to load async values before they will be shown
+     */
+    prepareItems() {
+        if (!this._itemsValuesLoaded) {
+            this._itemsValuesLoaded = true;
+            this.loadAsyncValues();
+        }
+    }
+    updateItemsVisiblity() {
+        this.visibleItems = this.items
+            .filter((item) => !item.isTypeKeyword && !item.hide);
+    }
+    _createItems(items) {
+        this._items = items
+            .filter((item) => !item.disable)
+            .filter((item) => {
+            if (this._itemsByName.has(item.name)) {
+                throw Error('Filter init error. Items name must be unique.');
+            }
+            else {
+                this._itemsByName.set(item.name, null);
+                return true;
+            }
+        })
+            .map((item) => {
+            const filterItem = createFilterItem(item, { case: this._config.case }, this.filter);
+            if (filterItem.type === ItemType.Keyword) {
+                this._hasKeyword = true;
+            }
+            this._itemsByName.set(item.name, filterItem);
+            return filterItem;
+        });
+        this._createSortingItems();
+    }
+    _subscribeToItemsChanges() {
+        this.items
+            .forEach((item) => {
+            item.valueChange$
+                .pipe(takeUntil(item.destroy$))
+                .subscribe(() => {
+                this._itemsChange$.next(item);
+            });
+        });
+        if (this._config.sortValues?.length) {
+            this.sortByItem.valueChange$
+                .pipe(takeUntil(this.sortByItem.destroy$))
+                .subscribe(() => {
+                this._itemsChange$.next(this.sortByItem);
+            });
+            this.sortDirectionItem.valueChange$
+                .pipe(takeUntil(this.sortDirectionItem.destroy$))
+                .subscribe(() => {
+                this._itemsChange$.next(this.sortDirectionItem);
+            });
+        }
+    }
+    _lazyInit() {
+        this.ready$
+            .pipe(filter((state) => state), takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.updateItemsVisiblity();
+            this._setKeywordItem();
+        });
+    }
+    _initSortingItems(p) {
+        if (this.sortByItem && this.sortDirectionItem) {
+            this.sortByItem.initValues(p[this.sortByItem.name]);
+            this.sortDirectionItem.initValues(p[this.sortDirectionItem.name]);
+        }
+    }
+    _createSortingItems() {
+        if (this._config.sortValues?.length > 0) {
+            const sortByItem = {
+                name: SORT_BY_FIELD,
+                type: ItemType.Select,
+                label: 'Sort By',
+                values: this._config.sortValues,
+            };
+            if (this._config.sort && this._config.sort.value) {
+                sortByItem.default = this._config.sort.value;
+            }
+            this.sortByItem = new SimpleSelectItem(sortByItem, null, this.filter);
+            const sortDirectionItem = {
+                name: SORT_DIRECTION_FIELD,
+                type: ItemType.Select,
+                label: 'Sort Direction',
+                values: [
+                    { name: 'Ascending', value: 'asc' },
+                    { name: 'Descending', value: 'desc' },
+                ],
+            };
+            if (this._config.sort && this._config.sort.direction) {
+                sortDirectionItem.default = this._config.sort.direction;
+            }
+            this.sortDirectionItem = new SimpleSelectItem(sortDirectionItem, null, this.filter);
+        }
+    }
+    _setKeywordItem() {
+        this.keywordItem = this
+            .items
+            .find((item) => item.isTypeKeyword);
+    }
+}
+FsFilterItemsStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFilterItemsStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FsFilterItemsStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFilterItemsStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: FsFilterItemsStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"items-store.service.js","sourceRoot":"","sources":["../../../../src/app/services/items-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\n\nimport { BehaviorSubject, forkJoin, Observable, Subject } from 'rxjs';\nimport { debounceTime, filter, finalize, takeUntil } from 'rxjs/operators';\n\nimport { pickBy } from 'lodash-es';\n\nimport type { FilterComponent } from '../components/filter/filter.component';\nimport { ItemType } from '../enums/item-type.enum';\nimport { createFilterItem } from '../helpers/create-filter-item';\nimport {\n  FilterSort,\n  IFilterConfigItem,\n} from '../interfaces/config.interface';\nimport { IFilterExternalParams } from '../interfaces/external-params.interface';\nimport { ISortingChangeEvent } from '../interfaces/filter.interface';\nimport { IFilterConfigSelectItem } from '../interfaces/items/select.interface';\nimport { FsFilterConfig, SORT_BY_FIELD, SORT_DIRECTION_FIELD } from '../models/filter-config';\nimport { BaseItem } from '../models/items/base-item';\nimport { BaseDateRangeItem } from '../models/items/date-range/base-date-range-item';\nimport { RangeItem } from '../models/items/range-item';\nimport { MultipleSelectItem } from '../models/items/select/multiple-select-item';\nimport { SimpleSelectItem } from '../models/items/select/simple-select-item';\nimport { TextItem } from '../models/items/text-item';\n\n\ninterface IValueAsQuery {\n  onlyPresented?: boolean;\n  items?: BaseItem<IFilterConfigItem>[];\n  persisted?: boolean;\n}\n\n@Injectable()\nexport class FsFilterItemsStore implements OnDestroy {\n\n  public sortByItem: BaseItem<IFilterConfigItem> = null;\n  public sortDirectionItem: BaseItem<IFilterConfigItem> = null;\n  public keywordItem: TextItem = null;\n  public filter: FilterComponent;\n\n  private _ready$ = new BehaviorSubject(false);\n  private _items: BaseItem<IFilterConfigItem>[] = [];\n  private _visibleItems$ = new BehaviorSubject<BaseItem<IFilterConfigItem>[]>([]);\n  private _itemsByName = new Map<string, BaseItem<IFilterConfigItem>>();\n\n  private _itemsValuesLoaded = false;\n  private _hasKeyword = false;\n  private _config: FsFilterConfig;\n\n  private _itemsChange$ = new Subject();\n  private _destroy$ = new Subject<void>();\n\n  constructor(\n  ) {\n    this._lazyInit();\n  }\n\n  public get items(): BaseItem<IFilterConfigItem>[] {\n    return this._items;\n  }\n\n  public get visibleItems(): BaseItem<IFilterConfigItem>[] {\n    return this._visibleItems$.getValue();\n  }\n\n  public set visibleItems(items: BaseItem<IFilterConfigItem>[]) {\n    this._visibleItems$.next(items);\n  }\n\n  public get visibleItems$(): Observable<BaseItem<IFilterConfigItem>[]> {\n    return this._visibleItems$.asObservable();\n  }\n\n  public get hasKeyword(): boolean {\n    return this._hasKeyword;\n  }\n\n  public get itemsChange$() {\n    return this._itemsChange$.pipe(debounceTime(30));\n  }\n\n  public get ready$() {\n    return this._ready$.asObservable();\n  }\n\n  public ngOnDestroy() {\n    this.destroyItems();\n\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  public setConfig(config) {\n    this._itemsByName.clear();\n    this._config = config;\n    this.initItems(config.items);\n  }\n\n  public getItemByName(name: string): BaseItem<IFilterConfigItem> {\n    return this._itemsByName.get(name);\n  }\n\n  public initItems(items: IFilterConfigItem[]) {\n    this._itemsValuesLoaded = false;\n    if (Array.isArray(items)) {\n      this._createItems(items);\n    }\n  }\n\n  public filtersClear() {\n    this.items.forEach((item) => {\n      if (item instanceof RangeItem) {\n        item.clearRange(null, item.defaultValue);\n      } else if (item instanceof BaseDateRangeItem) {\n        item.clearDateRange(null, item.defaultValue);\n      } else {\n        item.clear(item.defaultValue);\n      }\n    });\n\n    if (this.sortByItem) {\n      if (this._config.sort) {\n        this.sortByItem.model = this._config.sort.value;\n      } else {\n        this.sortByItem.clear(this.sortByItem.defaultValue);\n      }\n    }\n\n    if (this.sortDirectionItem) {\n      if (this._config.sort) {\n        this.sortDirectionItem.model = this._config.sort.direction;\n      } else {\n        this.sortDirectionItem.clear(this.sortDirectionItem.defaultValue);\n      }\n    }\n\n    this.keywordItem?.clear();\n  }\n\n  public loadAsyncValues() {\n    this.items\n      .filter((item) => item.hasPendingValues)\n      .forEach((item) => item.loadAsyncValues());\n  }\n\n  public loadAsyncDefaults(): void {\n    // default values can be asynchronous, and we must load them if there is no persisted value instead\n    const defaultValuesToBeLoaded = this.items\n      .filter((item) => {\n        return item.defaultValueFn\n          && (item.persistedValue === null || item.persistedValue === undefined);\n      });\n\n    // special hack for isolate multiple select\n    // values for this type of select must be preloaded\n    // Read more in class MultipleSelectItem._init()\n    const valuesToBeLoaded = this.items\n      .filter((item) => {\n        return (item instanceof MultipleSelectItem) && item.hasPendingValues && item.isolate;\n      });\n\n    if (defaultValuesToBeLoaded.length > 0 || valuesToBeLoaded.length > 0) {\n      forkJoin(\n        [\n          ...defaultValuesToBeLoaded\n            .map((item) => item.loadDefaultValue()),\n\n          ...valuesToBeLoaded\n            .map((item) => {\n              item.loadAsyncValues();\n\n              return item.loading$\n                .pipe();\n            }),\n        ],\n      )\n        .pipe(\n          finalize(() => {\n            this._ready$.next(true);\n          }),\n          takeUntil(this._destroy$),\n        )\n        .subscribe();\n    } else {\n      this._ready$.next(true);\n    }\n  }\n\n  public getSort(): FilterSort {\n    let sortBy = this.getSortByValue();\n    sortBy = sortBy === '__all' ? null : sortBy;\n\n    let sortDirection = this.getSortDirectionValue();\n    sortDirection = sortDirection === '__all' ? null : sortDirection;\n\n    return {\n      value: sortBy,\n      direction: sortDirection,\n    };\n  }\n\n  public getSortByValue() {\n    return this.sortByItem ? this.sortByItem.model : null;\n  }\n\n  public getSortDirectionValue() {\n    return this.sortDirectionItem ? this.sortDirectionItem.model : null;\n  }\n\n  public updateSort(sort: ISortingChangeEvent) {\n    if (sort.sortBy) {\n      this.sortByItem.model = sort.sortBy;\n    }\n\n    if (sort.sortDirection) {\n      this.sortDirectionItem.model = sort.sortDirection;\n    }\n  }\n\n  public values(onlyPresented = false): Record<string, unknown> {\n    return this.items.reduce((acc, item) => {\n      const value = item.value;\n\n      if (!onlyPresented || value !== null) {\n        acc[item.name] = value;\n      }\n\n      return acc;\n    }, {});\n  }\n\n  public valuesAsQuery({\n    onlyPresented = true,\n    items = null,\n    persisted = false,\n  }: IValueAsQuery = {}): Record<string, unknown> {\n    const params = {};\n\n    (items || this.items).forEach((filterItem: BaseItem<any>) => {\n      const values = persisted\n        ? filterItem.persistanceObject\n        : filterItem.queryObject;\n\n      Object.assign(params, values);\n    });\n\n    if (onlyPresented) {\n      return pickBy(params, (val) => {\n        return val !== void 0;\n      });\n    }\n\n    return params;\n  }\n\n  public init(p: IFilterExternalParams) {\n    this.items\n      .forEach((item) => {\n        item.initValues(p[item.name]);\n      });\n\n    this._initSortingItems(p);\n    this.loadAsyncDefaults();\n    this._subscribeToItemsChanges();\n  }\n\n  public updateItemsWithValues(values: IFilterExternalParams) {\n    this.items\n      .forEach((item) => {\n        if (values[item.name]) {\n          item.model = values[item.name];\n        } else {\n          if (item instanceof RangeItem) {\n            item.clearRange(null, item.defaultValue);\n          } else if (item instanceof BaseDateRangeItem) {\n            item.clearDateRange(null, item.defaultValue);\n          } else {\n            item.clear();\n          }\n        }\n      });\n\n    if (this.sortByItem) {\n      this.sortByItem.clear();\n    }\n    if (this.sortDirectionItem) {\n      this.sortDirectionItem.clear();\n    }\n  }\n\n  public destroyItems() {\n    this.items\n      .forEach((item) => item.destroy());\n    this.sortByItem?.destroy();\n    this.sortDirectionItem?.destroy();\n\n    this._items = [];\n    this.sortByItem = null;\n    this.sortDirectionItem = null;\n  }\n\n  /**\n   * Some items might need to load async values before they will be shown\n   */\n  public prepareItems() {\n    if (!this._itemsValuesLoaded) {\n      this._itemsValuesLoaded = true;\n\n      this.loadAsyncValues();\n    }\n  }\n\n  public updateItemsVisiblity(): void {\n    this.visibleItems = this.items\n      .filter((item) => !item.isTypeKeyword && !item.hide);\n  }\n\n  private _createItems(items: IFilterConfigItem[]) {\n    this._items = items\n      .filter((item) => !item.disable)\n      .filter((item) => {\n        if (this._itemsByName.has(item.name)) {\n          throw Error('Filter init error. Items name must be unique.');\n        } else {\n          this._itemsByName.set(item.name, null);\n\n          return true;\n        }\n      })\n      .map((item) => {\n        const filterItem = createFilterItem(item, { case: this._config.case }, this.filter);\n\n        if (filterItem.type === ItemType.Keyword) {\n          this._hasKeyword = true;\n        }\n\n        this._itemsByName.set(item.name, filterItem);\n\n        return filterItem;\n      });\n\n    this._createSortingItems();\n  }\n\n  private _subscribeToItemsChanges() {\n    this.items\n      .forEach((item) => {\n        item.valueChange$\n          .pipe(\n            takeUntil(item.destroy$),\n          )\n          .subscribe(() => {\n            this._itemsChange$.next(item);\n          });\n      });\n\n    if (this._config.sortValues?.length) {\n      this.sortByItem.valueChange$\n        .pipe(\n          takeUntil(this.sortByItem.destroy$),\n        )\n        .subscribe(() => {\n          this._itemsChange$.next(this.sortByItem);\n        });\n\n      this.sortDirectionItem.valueChange$\n        .pipe(\n          takeUntil(this.sortDirectionItem.destroy$),\n        )\n        .subscribe(() => {\n          this._itemsChange$.next(this.sortDirectionItem);\n        });\n    }\n  }\n\n  private _lazyInit(): void {\n    this.ready$\n      .pipe(\n        filter((state) => state),\n        takeUntil(this._destroy$),\n      )\n      .subscribe(() => {\n        this.updateItemsVisiblity();\n        this._setKeywordItem();\n      });\n  }\n\n  private _initSortingItems(p: IFilterExternalParams): void {\n    if (this.sortByItem && this.sortDirectionItem) {\n      this.sortByItem.initValues(p[this.sortByItem.name]);\n      this.sortDirectionItem.initValues(p[this.sortDirectionItem.name]);\n    }\n  }\n\n  private _createSortingItems(): void {\n    if (this._config.sortValues?.length > 0) {\n      const sortByItem = {\n        name: SORT_BY_FIELD,\n        type: ItemType.Select,\n        label: 'Sort By',\n        values: this._config.sortValues,\n      } as IFilterConfigSelectItem;\n\n\n      if (this._config.sort && this._config.sort.value) {\n        sortByItem.default = this._config.sort.value;\n      }\n\n      this.sortByItem = new SimpleSelectItem(\n        sortByItem,\n        null,\n        this.filter,\n      );\n\n      const sortDirectionItem = {\n        name: SORT_DIRECTION_FIELD,\n        type: ItemType.Select,\n        label: 'Sort Direction',\n        values: [\n          { name: 'Ascending', value: 'asc' },\n          { name: 'Descending', value: 'desc' },\n        ],\n      } as IFilterConfigSelectItem;\n\n      if (this._config.sort && this._config.sort.direction) {\n        sortDirectionItem.default = this._config.sort.direction;\n      }\n\n      this.sortDirectionItem = new SimpleSelectItem(\n        sortDirectionItem,\n        null,\n        this.filter,\n      );\n    }\n  }\n\n  private _setKeywordItem() {\n    this.keywordItem = this\n      .items\n      .find((item) => item.isTypeKeyword) as TextItem;\n  }\n}\n"]}

package/{esm2015/firestitch-filter.js → esm2020/firestitch-filter.mjs}

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public_api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZXN0aXRjaC1maWx0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmlyZXN0aXRjaC1maWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/{esm2015/public_api.js → esm2020/public_api.mjs}

@@ -1,37 +1,37 @@
-// Controllers
-export { ExternalParamsController } from './app/services/external-params-controller.service';
-export { SavedFiltersController } from './app/services/external-params/saved-filters-controller.service';
-// Modules
-export { FsFilterModule } from './app/fs-filter.module';
-// Components
-export { FilterComponent } from './app/components/filter/filter.component';
-export { FilterItemComponent } from './app/components/filters-item/filter-item.component';
-export { FsSavedFiltersMenuComponent } from './app/components/saved-filters-menu/saved-filters-menu.component';
-// Directives
-export { FilterStatusBarDirective } from './app/directives/status-bar/status-bar.directive';
-// Enums
-export { ActionType, ButtonStyle } from './app/enums';
-export { ActionMode } from './app/enums/action-mode.enum';
-export { ItemDateMode } from './app/enums/item-date-mode.enum';
-export { ItemType } from './app/enums/item-type.enum';
-// Models
-export { AutocompleteChipsItem } from './app/models/items/autocomplete-chips-item';
-export { AutocompleteItem } from './app/models/items/autocomplete-item';
-export { BaseItem } from './app/models/items/base-item';
-export { CheckboxItem } from './app/models/items/checkbox-item';
-export { ChipsItem } from './app/models/items/chips-item';
-export { DateItem } from './app/models/items/date-item';
-export { DateRangeItem } from './app/models/items/date-range-item';
-export { DateTimeItem } from './app/models/items/date-time-item';
-export { DateTimeRangeItem } from './app/models/items/date-time-range-item';
-export { RangeItem } from './app/models/items/range-item';
-export { SelectItem } from './app/models/items/select-item';
-export { TextItem } from './app/models/items/text-item';
-// Injectors
-export { FS_FILTER_CONFIG } from './app/injectors/filter-config';
-// Helpers
-export { buildQueryParams } from './app/helpers/build-query-params';
-export { filterFromQueryParam, filterToQueryParam } from './app/helpers/query-param-transformers';
-// Const
-export { QUERY_PARAM_DELIMITER } from './app/consts/query-param-delimiter';
+// Controllers
+export { ExternalParamsController } from './app/services/external-params-controller.service';
+export { SavedFiltersController } from './app/services/external-params/saved-filters-controller.service';
+// Modules
+export { FsFilterModule } from './app/fs-filter.module';
+// Components
+export { FilterComponent } from './app/components/filter/filter.component';
+export { FilterItemComponent } from './app/components/filters-item/filter-item.component';
+export { FsSavedFiltersMenuComponent } from './app/components/saved-filters-menu/saved-filters-menu.component';
+// Directives
+export { FilterStatusBarDirective } from './app/directives/status-bar/status-bar.directive';
+// Enums
+export { ActionType, ButtonStyle } from './app/enums';
+export { ActionMode } from './app/enums/action-mode.enum';
+export { ItemDateMode } from './app/enums/item-date-mode.enum';
+export { ItemType } from './app/enums/item-type.enum';
+// Models
+export { AutocompleteChipsItem } from './app/models/items/autocomplete-chips-item';
+export { AutocompleteItem } from './app/models/items/autocomplete-item';
+export { BaseItem } from './app/models/items/base-item';
+export { CheckboxItem } from './app/models/items/checkbox-item';
+export { ChipsItem } from './app/models/items/chips-item';
+export { DateItem } from './app/models/items/date-item';
+export { DateRangeItem } from './app/models/items/date-range-item';
+export { DateTimeItem } from './app/models/items/date-time-item';
+export { DateTimeRangeItem } from './app/models/items/date-time-range-item';
+export { RangeItem } from './app/models/items/range-item';
+export { SelectItem } from './app/models/items/select-item';
+export { TextItem } from './app/models/items/text-item';
+// Injectors
+export { FS_FILTER_CONFIG } from './app/injectors/filter-config';
+// Helpers
+export { buildQueryParams } from './app/helpers/build-query-params';
+export { filterFromQueryParam, filterToQueryParam } from './app/helpers/query-param-transformers';
+// Const
+export { QUERY_PARAM_DELIMITER } from './app/consts/query-param-delimiter';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxtREFBbUQsQ0FBQztBQUM3RixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpRUFBaUUsQ0FBQztBQUV6RyxVQUFVO0FBQ1YsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXhELGFBQWE7QUFDYixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDM0UsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scURBQXFELENBQUM7QUFDMUYsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sa0VBQWtFLENBQUM7QUFFL0csYUFBYTtBQUNiLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBK0I1RixRQUFRO0FBQ1IsT0FBTyxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDdEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzFELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMvRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFdEQsU0FBUztBQUNULE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBQ25GLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3hFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDaEUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzFELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDbkUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDNUQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXhELFlBQVk7QUFDWixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdqRSxVQUFVO0FBQ1YsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFFbEcsUUFBUTtBQUNSLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29udHJvbGxlcnNcbmV4cG9ydCB7IEV4dGVybmFsUGFyYW1zQ29udHJvbGxlciB9IGZyb20gJy4vYXBwL3NlcnZpY2VzL2V4dGVybmFsLXBhcmFtcy1jb250cm9sbGVyLnNlcnZpY2UnO1xuZXhwb3J0IHsgU2F2ZWRGaWx0ZXJzQ29udHJvbGxlciB9IGZyb20gJy4vYXBwL3NlcnZpY2VzL2V4dGVybmFsLXBhcmFtcy9zYXZlZC1maWx0ZXJzLWNvbnRyb2xsZXIuc2VydmljZSc7XG5cbi8vIE1vZHVsZXNcbmV4cG9ydCB7IEZzRmlsdGVyTW9kdWxlIH0gZnJvbSAnLi9hcHAvZnMtZmlsdGVyLm1vZHVsZSc7XG5cbi8vIENvbXBvbmVudHNcbmV4cG9ydCB7IEZpbHRlckNvbXBvbmVudCB9IGZyb20gJy4vYXBwL2NvbXBvbmVudHMvZmlsdGVyL2ZpbHRlci5jb21wb25lbnQnO1xuZXhwb3J0IHsgRmlsdGVySXRlbUNvbXBvbmVudCB9IGZyb20gJy4vYXBwL2NvbXBvbmVudHMvZmlsdGVycy1pdGVtL2ZpbHRlci1pdGVtLmNvbXBvbmVudCc7XG5leHBvcnQgeyBGc1NhdmVkRmlsdGVyc01lbnVDb21wb25lbnQgfSBmcm9tICcuL2FwcC9jb21wb25lbnRzL3NhdmVkLWZpbHRlcnMtbWVudS9zYXZlZC1maWx0ZXJzLW1lbnUuY29tcG9uZW50JztcblxuLy8gRGlyZWN0aXZlc1xuZXhwb3J0IHsgRmlsdGVyU3RhdHVzQmFyRGlyZWN0aXZlIH0gZnJvbSAnLi9hcHAvZGlyZWN0aXZlcy9zdGF0dXMtYmFyL3N0YXR1cy1iYXIuZGlyZWN0aXZlJztcblxuLy8gSW50ZXJmYWNlc1xuZXhwb3J0IHtcbiAgRnNGaWx0ZXJBY3Rpb24sXG4gIEZzRmlsdGVyQWN0aW9uQ2xpY2tGbiwgRnNGaWx0ZXJBY3Rpb25EaXNhYmxlZEZuLCBGc0ZpbHRlckFjdGlvblNob3dGbixcbiAgRnNGaWx0ZXJGaWxlQWN0aW9uRXJyb3JGbixcbiAgRnNGaWx0ZXJGaWxlQWN0aW9uU2VsZWN0Rm4sIElGc0ZpbHRlckJ1dHRvbkFjdGlvbixcbiAgSUZzRmlsdGVyRmlsZUFjdGlvbiwgSUZzRmlsdGVyTWVudUFjdGlvbiwgSUZzRmlsdGVyTWVudUFjdGlvbkdyb3VwSXRlbSxcbiAgSUZzRmlsdGVyTWVudUFjdGlvbkl0ZW0sIElGc0ZpbHRlck1lbnVBY3Rpb25MaW5rXG59IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvYWN0aW9uLmludGVyZmFjZSc7XG5leHBvcnQgeyBJRmlsdGVyQ29uZmlnQXV0b2NvbXBsZXRlQ2hpcHNJdGVtIH0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9pdGVtcy9hdXRvY29tcGxldGUtY2hpcHMuaW50ZXJmYWNlJztcbmV4cG9ydCB7IElGaWx0ZXJDb25maWdBdXRvY29tcGxldGVJdGVtIH0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9pdGVtcy9hdXRvY29tcGxldGUuaW50ZXJmYWNlJztcbmV4cG9ydCB7IElGaWx0ZXJDb25maWdCYXNlSXRlbSB9IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvaXRlbXMvYmFzZS5pbnRlcmZhY2UnO1xuZXhwb3J0IHsgSUZpbHRlckNvbmZpZ0NoZWNrYm94SXRlbSB9IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvaXRlbXMvY2hlY2tib3guaW50ZXJmYWNlJztcbmV4cG9ydCB7IElGaWx0ZXJDb25maWdDaGlwc0l0ZW0gfSBmcm9tICcuL2FwcC9pbnRlcmZhY2VzL2l0ZW1zL2NoaXBzLmludGVyZmFjZSc7XG5leHBvcnQgeyBJRmlsdGVyQ29uZmlnRGF0ZVJhbmdlSXRlbSwgSUZpbHRlckl0ZW1EZWZhdWx0RGF0ZVJhbmdlIH0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9pdGVtcy9kYXRlLXJhbmdlLmludGVyZmFjZSc7XG5leHBvcnQgeyBJRmlsdGVyQ29uZmlnRGF0ZUl0ZW0gfSBmcm9tICcuL2FwcC9pbnRlcmZhY2VzL2l0ZW1zL2RhdGUuaW50ZXJmYWNlJztcbmV4cG9ydCB7IElGaWx0ZXJDb25maWdSYW5nZUl0ZW0sIElGaWx0ZXJJdGVtRGVmYXVsdFJhbmdlIH0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9pdGVtcy9yYW5nZS5pbnRlcmZhY2UnO1xuZXhwb3J0IHsgRmlsdGVyVmFsdWVzUmV0dXJuRm4sIElGaWx0ZXJDb25maWdTZWxlY3RJc29sYXRlLCBJRmlsdGVyQ29uZmlnU2VsZWN0SXRlbSwgSUZpbHRlclNlbGVjdFZhbHVlIH0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9pdGVtcy9zZWxlY3QuaW50ZXJmYWNlJztcbmV4cG9ydCB7IElGaWx0ZXJDb25maWdUZXh0SXRlbSB9IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvaXRlbXMvdGV4dC5pbnRlcmZhY2UnO1xuXG5leHBvcnQge1xuICBDaGFuZ2VGbiwgRmlsdGVyQ29uZmlnLCBGaWx0ZXJTb3J0LCBGc0ZpbHRlclBlcnNpc3RhbmNlLCBJRmlsdGVyQ29uZmlnSXRlbSwgU29ydCwgU29ydEl0ZW1cbn0gZnJvbSAnLi9hcHAvaW50ZXJmYWNlcy9jb25maWcuaW50ZXJmYWNlJztcblxuZXhwb3J0IHtcbiAgRmlsdGVyUmVtb3RlRGVsZXRlLCBGaWx0ZXJSZW1vdGVMb2FkLCBGaWx0ZXJSZW1vdGVPcmRlciwgRmlsdGVyUmVtb3RlU2F2ZSwgSUZpbHRlclNhdmVkRmlsdGVyLFxuICBJRmlsdGVyU2F2ZWRGaWx0ZXJzQ29uZmlnXG59IGZyb20gJy4vYXBwL2ludGVyZmFjZXMvc2F2ZWQtZmlsdGVycy5pbnRlcmZhY2UnO1xuXG4vLyBFbnVtc1xuZXhwb3J0IHsgQWN0aW9uVHlwZSwgQnV0dG9uU3R5bGUgfSBmcm9tICcuL2FwcC9lbnVtcyc7XG5leHBvcnQgeyBBY3Rpb25Nb2RlIH0gZnJvbSAnLi9hcHAvZW51bXMvYWN0aW9uLW1vZGUuZW51bSc7XG5leHBvcnQgeyBJdGVtRGF0ZU1vZGUgfSBmcm9tICcuL2FwcC9lbnVtcy9pdGVtLWRhdGUtbW9kZS5lbnVtJztcbmV4cG9ydCB7IEl0ZW1UeXBlIH0gZnJvbSAnLi9hcHAvZW51bXMvaXRlbS10eXBlLmVudW0nO1xuXG4vLyBNb2RlbHNcbmV4cG9ydCB7IEF1dG9jb21wbGV0ZUNoaXBzSXRlbSB9IGZyb20gJy4vYXBwL21vZGVscy9pdGVtcy9hdXRvY29tcGxldGUtY2hpcHMtaXRlbSc7XG5leHBvcnQgeyBBdXRvY29tcGxldGVJdGVtIH0gZnJvbSAnLi9hcHAvbW9kZWxzL2l0ZW1zL2F1dG9jb21wbGV0ZS1pdGVtJztcbmV4cG9ydCB7IEJhc2VJdGVtIH0gZnJvbSAnLi9hcHAvbW9kZWxzL2l0ZW1zL2Jhc2UtaXRlbSc7XG5leHBvcnQgeyBDaGVja2JveEl0ZW0gfSBmcm9tICcuL2FwcC9tb2RlbHMvaXRlbXMvY2hlY2tib3gtaXRlbSc7XG5leHBvcnQgeyBDaGlwc0l0ZW0gfSBmcm9tICcuL2FwcC9tb2RlbHMvaXRlbXMvY2hpcHMtaXRlbSc7XG5leHBvcnQgeyBEYXRlSXRlbSB9IGZyb20gJy4vYXBwL21vZGVscy9pdGVtcy9kYXRlLWl0ZW0nO1xuZXhwb3J0IHsgRGF0ZVJhbmdlSXRlbSB9IGZyb20gJy4vYXBwL21vZGVscy9pdGVtcy9kYXRlLXJhbmdlLWl0ZW0nO1xuZXhwb3J0IHsgRGF0ZVRpbWVJdGVtIH0gZnJvbSAnLi9hcHAvbW9kZWxzL2l0ZW1zL2RhdGUtdGltZS1pdGVtJztcbmV4cG9ydCB7IERhdGVUaW1lUmFuZ2VJdGVtIH0gZnJvbSAnLi9hcHAvbW9kZWxzL2l0ZW1zL2RhdGUtdGltZS1yYW5nZS1pdGVtJztcbmV4cG9ydCB7IFJhbmdlSXRlbSB9IGZyb20gJy4vYXBwL21vZGVscy9pdGVtcy9yYW5nZS1pdGVtJztcbmV4cG9ydCB7IFNlbGVjdEl0ZW0gfSBmcm9tICcuL2FwcC9tb2RlbHMvaXRlbXMvc2VsZWN0LWl0ZW0nO1xuZXhwb3J0IHsgVGV4dEl0ZW0gfSBmcm9tICcuL2FwcC9tb2RlbHMvaXRlbXMvdGV4dC1pdGVtJztcblxuLy8gSW5qZWN0b3JzXG5leHBvcnQgeyBGU19GSUxURVJfQ09ORklHIH0gZnJvbSAnLi9hcHAvaW5qZWN0b3JzL2ZpbHRlci1jb25maWcnO1xuXG5cbi8vIEhlbHBlcnNcbmV4cG9ydCB7IGJ1aWxkUXVlcnlQYXJhbXMgfSBmcm9tICcuL2FwcC9oZWxwZXJzL2J1aWxkLXF1ZXJ5LXBhcmFtcyc7XG5leHBvcnQgeyBmaWx0ZXJGcm9tUXVlcnlQYXJhbSwgZmlsdGVyVG9RdWVyeVBhcmFtIH0gZnJvbSAnLi9hcHAvaGVscGVycy9xdWVyeS1wYXJhbS10cmFuc2Zvcm1lcnMnO1xuXG4vLyBDb25zdFxuZXhwb3J0IHsgUVVFUllfUEFSQU1fREVMSU1JVEVSIH0gZnJvbSAnLi9hcHAvY29uc3RzL3F1ZXJ5LXBhcmFtLWRlbGltaXRlcic7XG4iXX0=