@colijnit/corecomponents_v12 12.2.25 → 12.2.26

package/esm2015/lib/components/filter-item/filter-item.component.js

@@ -0,0 +1,646 @@
+import { __awaiter } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { CoreComponentsIcon } from '../../core/enum/core-components-icon.enum';
+import { IconCacheService } from '../icon/icon-cache.service';
+import { FilterItemMode } from '../../core/enum/filterItem-mode.enum';
+export class FilterItemComponent {
+    constructor(iconService, _changeDetector) {
+        this.iconService = iconService;
+        this._changeDetector = _changeDetector;
+        this.icons = CoreComponentsIcon;
+        this.modes = FilterItemMode;
+        this.initialLimit = 10;
+        this.expanded = false;
+        // Set to false to use filter item with a multi selectable collection. Set to true to specify custom content
+        this.customContent = false;
+        // Set to true to show all results. Set to false to get 'show more' and 'show less' buttons to expand and contract.
+        this.showAllResults = false;
+        this.filterButtonLabel = "Search";
+        this.searchPlaceholder = 'Search...';
+        this.showMoreLabel = 'Show more';
+        this.showLessLabel = 'Show less';
+        this.noResultsLabel = "No results";
+        this.sliderDefaultMin = 0;
+        this.sliderDefaultMax = 100000;
+        this.fullRangeIsNull = false;
+        this.modelChange = new EventEmitter();
+        this.collectionChange = new EventEmitter();
+        this.filterButtonClicked = new EventEmitter();
+        this.filteredCollection = [];
+        this.limitTo = 10;
+        this.filterText = "";
+        this.showButton = false;
+        this._collection = [];
+        this._mode = this.modes.Filterlist;
+    }
+    set mode(value) {
+        this._mode = value;
+        this.readModelForMode(this._model);
+    }
+    get mode() {
+        return this._mode;
+    }
+    set collection(value) {
+        var _a;
+        this._collection = value;
+        this.filteredCollection = (_a = this._collection) === null || _a === void 0 ? void 0 : _a.slice();
+        //reset the model in case there was no collection to set its values on when it was set.
+        this.model = this._model;
+    }
+    get collection() {
+        return this._collection;
+    }
+    set model(newModel) {
+        this.readModelForMode(newModel);
+    }
+    get model() {
+        return this._model;
+    }
+    ngOnInit() {
+        this.setToInitialLimit();
+        this.showButton = this.valueSelected();
+        if (this.checkBoxToTextModel === undefined || this.checkBoxToTextModel === null) {
+            this.checkBoxToTextModel = false;
+        }
+    }
+    setToInitialLimit() {
+        this.limitTo = this.initialLimit;
+    }
+    increaseLimit() {
+        this.limitTo += 10;
+    }
+    moreToShow() {
+        var _a;
+        if (this.showAllResults) {
+            return false;
+        }
+        return ((_a = this.filteredCollection) === null || _a === void 0 ? void 0 : _a.length) > this.limitTo;
+    }
+    lessToShow() {
+        var _a, _b;
+        if (this.showAllResults) {
+            return false;
+        }
+        return ((_a = this.filteredCollection) === null || _a === void 0 ? void 0 : _a.length) <= this.limitTo && ((_b = this.filteredCollection) === null || _b === void 0 ? void 0 : _b.length) > this.initialLimit;
+    }
+    handleModelChange(model) {
+        switch (this.mode) {
+            case this.modes.Filterlist:
+                this.showButton = true;
+                model.checked = !model.checked;
+                this._createModelForFilterList();
+                break;
+            case this.modes.SelectListWithStringCollectionOutput:
+                this.showButton = true;
+                model.checked = !model.checked;
+                this._createModelForStringCollectionList();
+                break;
+            case this.modes.SingleSelectList:
+                this.showButton = true;
+                this.uncheckForSingleSelect(model);
+                model.checked = !model.checked;
+                this._createModelForSingleSelectList();
+                break;
+            case this.modes.SelectListWithNumberOutput:
+                this.showButton = true;
+                model.checked = !model.checked;
+                this._createModelForSelectListWithNumberOutput();
+                break;
+            case this.modes.Slider:
+                this.showButton = true;
+                this._createModelForSliderMode();
+                break;
+            case this.modes.NullableSlider:
+                this.showButton = true;
+                this._createModelForNullableSliderMode();
+                break;
+            case this.modes.CheckboxToText:
+                this.showButton = true;
+                this._createModelForCheckboxToText();
+                break;
+            case this.modes.CheckboxToSimpleText:
+                this.showButton = true;
+                this._createModelForCheckboxToSimpleText();
+                break;
+            case this.modes.CheckboxToBinary:
+                this.showButton = true;
+                this._createModelForCheckboxToBinary();
+                break;
+            case this.modes.DateRangeField:
+                this.showButton = true;
+                this._createModelForDateRange(model);
+                break;
+            case this.modes.TextField:
+                this.showButton = true;
+                this._model = (typeof this._model === 'string' && this._model.length === 0) ? undefined : this._model;
+                break;
+        }
+        this.modelChange.emit(this._model);
+        this.collectionChange.emit(this.collection);
+    }
+    valueSelected() {
+        if (this.collection) {
+            return !!this.collection.find(c => c.checked);
+        }
+        return false;
+    }
+    // Applies filter to the collection.
+    applyFilter(text) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isNaN(this.minSearchCharsToLoadCollection) && this.collectionLoadFn) {
+                if (text.length === this.minSearchCharsToLoadCollection && text.length > this.filterText.length) {
+                    this.collection = yield this.collectionLoadFn(text);
+                }
+                else if (text.length < this.minSearchCharsToLoadCollection) {
+                    this.collection = undefined;
+                }
+            }
+            this.filterText = text;
+            if (!this.collection) {
+                return [];
+            }
+            const filterText = (_a = this.filterText) === null || _a === void 0 ? void 0 : _a.toString().toLowerCase();
+            let filteredItemCount = 0;
+            this.filteredCollection = (_b = this.collection) === null || _b === void 0 ? void 0 : _b.filter((item) => {
+                var _a;
+                const labelText = (_a = item.description) === null || _a === void 0 ? void 0 : _a.toString().toLowerCase();
+                const isHiddenByFilter = ((labelText === null || labelText === void 0 ? void 0 : labelText.indexOf(filterText)) === -1);
+                if (isHiddenByFilter) {
+                    return false;
+                }
+                else {
+                    filteredItemCount++;
+                    return true;
+                }
+            });
+        });
+    }
+    onButtonClicked() {
+        this.filterButtonClicked.emit();
+    }
+    uncheckForSingleSelect(model) {
+        this.collection.forEach(m => {
+            if (m.code !== model.code && m.description !== model.description) {
+                m.checked = false;
+            }
+        });
+    }
+    readModelForMode(newModel) {
+        switch (this.mode) {
+            case this.modes.Filterlist:
+                this._readModelForFilterList(newModel);
+                break;
+            case this.modes.SingleSelectList:
+                this._readModelForSingleSelectList(newModel);
+                break;
+            case this.modes.SelectListWithStringCollectionOutput:
+                this._readModelForStringCollectionList(newModel);
+                break;
+            case this.modes.SelectListWithNumberOutput:
+                this._readModelForSelectListWithNumberOutput(newModel);
+                break;
+            case this.modes.Slider:
+            case this.modes.NullableSlider:
+                this._readModelForSliderMode(newModel);
+                break;
+            case this.modes.CheckboxToText:
+            case this.modes.CheckboxToSimpleText:
+                this._readModelForCheckboxToText(newModel);
+                break;
+            case this.modes.CheckboxToBinary:
+                this._readModelForCheckboxToBinary(newModel);
+                break;
+            case this.modes.DateField:
+                this._readModelForDateField(newModel);
+                break;
+            case this.modes.DateRangeField:
+                this._readModelForDateRangeField(newModel);
+                break;
+            default:
+                this._model = newModel;
+        }
+    }
+    /////////////////////////////////////////////////////////////
+    //Model creation for all of the different options available//
+    /////////////////////////////////////////////////////////////
+    _createModelForFilterList() {
+        let filterRange = [];
+        if (this.collection !== null && this.collection !== undefined) {
+            this.collection.forEach((viewModel) => {
+                if (viewModel.checked) {
+                    filterRange.push(`?='${viewModel.code}'`);
+                }
+            });
+            if (filterRange.length > 0) {
+                this._model = filterRange.join(',');
+            }
+            else {
+                this._model = undefined;
+            }
+        }
+    }
+    _createModelForStringCollectionList() {
+        let filterRange = [];
+        this.collection.forEach((viewModel) => {
+            if (viewModel.checked) {
+                filterRange.push(viewModel.code.toString());
+            }
+        });
+        if (filterRange.length > 0) {
+            this._model = filterRange;
+        }
+        else {
+            this._model = undefined;
+        }
+    }
+    _createModelForSingleSelectList() {
+        let filterString = "";
+        this.collection.forEach((viewModel) => {
+            if (viewModel.checked) {
+                filterString = viewModel.code.toString();
+            }
+        });
+        if (filterString.length > 0) {
+            this._model = filterString;
+        }
+        else {
+            this._model = undefined;
+        }
+    }
+    _createModelForSelectListWithNumberOutput() {
+        let filterNumber = null;
+        this.collection.forEach((viewModel) => {
+            if (viewModel.checked) {
+                if (filterNumber == null) {
+                    filterNumber = 0;
+                }
+                filterNumber += Number(viewModel.code);
+            }
+        });
+        this._model = filterNumber;
+    }
+    _createModelForSliderMode() {
+        this.sliderMin = !!this.sliderMin ? this.sliderMin : this.sliderDefaultMin;
+        this.sliderMax = !!this.sliderMax ? this.sliderMax : this.sliderDefaultMax;
+        let trueLowerBound = Math.min(this.sliderMin, this.sliderMax);
+        let trueUpperBound = Math.max(this.sliderMin, this.sliderMax);
+        this.sliderMin = trueLowerBound;
+        this.sliderMax = trueUpperBound;
+        this._model = `${trueLowerBound} - ${trueUpperBound}`;
+    }
+    _createModelForNullableSliderMode() {
+        if (this.sliderMin && this.sliderMax) {
+            let trueLowerBound = Math.min(this.sliderMin, this.sliderMax);
+            let trueUpperBound = Math.max(this.sliderMin, this.sliderMax);
+            this._model = `${trueLowerBound} - ${trueUpperBound}`;
+        }
+        else {
+            this._model = null;
+        }
+    }
+    _createModelForCheckboxToText() {
+        if (this.checkBoxToTextModel) {
+            this._model = "?='J'";
+        }
+        else {
+            this._model = "?='N'";
+        }
+    }
+    _createModelForCheckboxToSimpleText() {
+        if (this.checkBoxToTextModel) {
+            this._model = "J";
+        }
+        else {
+            this._model = "N";
+        }
+    }
+    _createModelForCheckboxToBinary() {
+        if (this.checkBoxToTextModel) {
+            this._model = 1;
+        }
+        else {
+            this._model = 0;
+        }
+    }
+    _createModelForDateRange(dates) {
+        if (dates) {
+            let startDate = dates[0];
+            let endDate = dates[1];
+            const startDateRequest = startDate ? this._formatDateToString(startDate) : '';
+            const endDateRequest = endDate ? this._formatDateToString(endDate) : '';
+            this._model = `?>=\'${startDateRequest}\'& ?<=\'${endDateRequest}\'`;
+        }
+    }
+    _formatDateToString(date) {
+        let day = date.getDate().toString().padStart(2, '0');
+        let month = (date.getMonth() + 1).toString().padStart(2, '0');
+        let year = date.getFullYear();
+        return `${day}-${month}-${year}`;
+    }
+    ////////////////////////////////////////////////////////////
+    //Model reading for all of the different options available//
+    ////////////////////////////////////////////////////////////
+    _readModelForFilterList(filterModel) {
+        let filterList = [];
+        let itemsToCheck = [];
+        this._uncheckAll();
+        this._model = filterModel;
+        if (filterModel !== null && filterModel !== undefined && typeof filterModel === 'string' && filterModel.length != 0 && this.collection !== null && this.collection !== undefined) {
+            filterList = filterModel.split(",");
+            filterList.forEach((filter) => {
+                itemsToCheck.push(filter.substr(3, filter.length - 4));
+            });
+            for (const item of itemsToCheck) {
+                let filter = this.collection.find(element => element.code.toString() === item);
+                if (filter !== null && filter !== undefined) {
+                    filter.checked = true;
+                }
+            }
+            this._model = filterModel;
+        }
+    }
+    _readModelForSingleSelectList(singleSelectModel) {
+        this._uncheckAll();
+        this._model = singleSelectModel;
+        if (singleSelectModel !== null && singleSelectModel !== undefined && this.collection !== null && this.collection !== undefined) {
+            let filter = this.collection.find(element => element.code.toString() === singleSelectModel);
+            if (filter !== null && filter !== undefined) {
+                filter.checked = true;
+            }
+        }
+    }
+    _readModelForStringCollectionList(collectionModel) {
+        this._uncheckAll();
+        this._model = collectionModel;
+        if (collectionModel !== null && collectionModel !== undefined && this.collection !== null && this.collection !== undefined) {
+            this.collection.forEach((viewModel) => {
+                if (collectionModel.indexOf(viewModel.code.toString()) > -1) {
+                    viewModel.checked = true;
+                }
+                else {
+                    viewModel.checked = false;
+                }
+            });
+        }
+    }
+    _readModelForSelectListWithNumberOutput(numberModel) {
+        this._uncheckAll();
+        this._model = numberModel;
+        if (numberModel !== null && numberModel !== undefined && this.collection !== null && this.collection !== undefined) {
+            for (const item of this.collection) {
+                const itemCode = item.code;
+                const modValue = (numberModel % (2 * itemCode));
+                item.checked = (modValue >= itemCode);
+            }
+        }
+    }
+    _uncheckAll() {
+        if (this.collection !== null && this.collection !== undefined) {
+            this.collection.forEach(m => {
+                m.checked = false;
+            });
+        }
+    }
+    _readModelForSliderMode(sliderModel) {
+        this._model = sliderModel;
+        if (sliderModel !== undefined && sliderModel !== null) {
+            let sliderInputCollection = sliderModel.split(' - ');
+            this.sliderMin = parseInt(sliderInputCollection[0]);
+            this.sliderMax = parseInt(sliderInputCollection[1]);
+        }
+        else {
+            this.sliderMin = this.sliderDefaultMin;
+            this.sliderMax = this.sliderDefaultMax;
+        }
+    }
+    _readModelForCheckboxToText(checkboxToTextModel) {
+        this._model = checkboxToTextModel;
+        if (checkboxToTextModel !== undefined && checkboxToTextModel !== null) {
+            this.checkBoxToTextModel = (checkboxToTextModel.indexOf('J') > -1);
+        }
+        else {
+            this.checkBoxToTextModel = false;
+        }
+    }
+    _readModelForCheckboxToBinary(checkboxToBinary) {
+        this._model = checkboxToBinary;
+        if (checkboxToBinary !== undefined && checkboxToBinary !== null) {
+            this.checkBoxToTextModel = (checkboxToBinary >= 1);
+        }
+        else {
+            this.checkBoxToTextModel = false;
+        }
+    }
+    _readModelForDateField(dateFieldModel) {
+        this._model = dateFieldModel;
+        if (dateFieldModel !== undefined && dateFieldModel !== null) {
+            this._model = new Date(dateFieldModel);
+        }
+        else {
+            this._model = undefined;
+        }
+    }
+    _readModelForDateRangeField(dateRangeFieldModel) {
+        this._model = dateRangeFieldModel;
+        if (dateRangeFieldModel !== undefined && dateRangeFieldModel !== null) {
+            let dateCollection = dateRangeFieldModel.split('&');
+            let startString = dateCollection[0].trim().substr(4, dateCollection[0].length - 5);
+            let endString = dateCollection[1].trim().substr(4, dateCollection[1].length - 5);
+            let startDateComponents = startString.split('-');
+            let endDateComponents = endString.split('-');
+            this.dateRangeStart = new Date(parseInt(startDateComponents[2]), parseInt(startDateComponents[1]) - 1, parseInt(startDateComponents[0]));
+            this.dateRangeEnd = new Date(parseInt(endDateComponents[2]), parseInt(endDateComponents[1]) - 1, parseInt(endDateComponents[0]));
+        }
+        else {
+            this.dateRangeStart = undefined;
+            this.dateRangeEnd = undefined;
+        }
+    }
+}
+FilterItemComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-filter-item",
+                template: `
+      <div class="co-filter-item-header">
+          <co-collapsible
+                  [headerTitle]="placeholder"
+                  [expandButtonLast]="true"
+                  [iconData]="iconService.getIcon(icons.ArrowPointDown)"
+                  [expanded]="expanded"
+                  [showButton]="showButton"
+                  [buttonText]="filterButtonLabel"
+                  (buttonClicked)="onButtonClicked()"
+          >
+              <div class="co-filter-item-collapsable-content">
+                  <div class="co-filter-item-custom-content" *ngIf="customContent; else collectionContent"
+                       (keydown)="showButton=true" (mousedown)="showButton=true">
+                      <ng-content></ng-content>
+                  </div>
+                  <ng-template #collectionContent>
+                      <div class="co-filter-item-collection-content" *ngIf="mode === modes.Filterlist || mode === modes.SingleSelectList
+                                                                   || mode === modes.SelectListWithNumberOutput || mode === modes.SelectListWithStringCollectionOutput">
+                          <co-input-text
+                                  *ngIf="collection?.length > 10 || minSearchCharsToLoadCollection"
+                                  [placeholder]="searchPlaceholder"
+                                  [model]="filterText"
+                                  (modelChange)="applyFilter($event)"
+                          >
+                          </co-input-text>
+                          <div class="no-results" *ngIf="filteredCollection?.length === 0">
+                              <span [textContent]="noResultsLabel"></span>
+                          </div>
+                          <div class="co-filter-item-collection-results">
+                              <ng-container
+                                      *ngFor="let option of filteredCollection; let index = index">
+                                  <div class="co-filter-item-collection-result-item" *ngIf="index < limitTo || showAllResults">
+                                      <co-input-checkbox *ngIf="mode !== modes.SingleSelectList"
+                                                         [label]="option.description"
+                                                         [model]="option.checked"
+                                                         [clickableLabel]="false"
+                                                         (modelChange)="handleModelChange(option)"
+                                      ></co-input-checkbox>
+                                      <co-input-radio-button *ngIf="mode === modes.SingleSelectList"
+                                                             [label]="option.description"
+                                                             [model]="option.checked"
+                                                             (modelChange)="handleModelChange(option)"
+                                      ></co-input-radio-button>
+                                      <div class="co-filter-item-amount" *ngIf="option.count"
+                                           [textContent]="option.count.toString() | append: ')' | prepend: '      ('"
+                                      ></div>
+                                  </div>
+
+                              </ng-container>
+                          </div>
+                          <div class="co-filter-show-more-or-less" *ngIf="!showAllResults">
+                              <div class="co-filter-show-more clickable"
+                                   *ngIf="moreToShow()">
+                                  <a (click)="increaseLimit()">
+                                      <co-icon [iconData]="iconService.getIcon(icons.ArrowPointDown)"></co-icon>
+                                      <span [textContent]="showMoreLabel"></span>
+                                  </a>
+                              </div>
+                              <div class="co-filter-show-less clickable"
+                                   *ngIf="lessToShow()">
+                                  <a (click)="setToInitialLimit()">
+                                      <co-icon [iconData]="iconService.getIcon(icons.ArrowPointUp)"></co-icon>
+                                      <span [textContent]="showLessLabel"></span>
+                                  </a>
+                              </div>
+                          </div>
+                      </div>
+                      <div class="co-filter-item-slider-content" *ngIf="mode === modes.Slider">
+                          <co-input-text
+                                  class="slider-from"
+                                  [type]="'number'"
+                                  [digitsOnly]="true"
+                                  [hideArrowButtons]="true"
+                                  [excludePlusMinus]="true"
+                                  [label]="'FROM' | coreLocalize"
+                                  [(model)]="sliderMin"
+                                  (focusout)="handleModelChange(sliderMin)"
+                          ></co-input-text>
+                          <co-input-text
+                                  class="slider-to"
+                                  [type]="'number'"
+                                  [digitsOnly]="true"
+                                  [hideArrowButtons]="true"
+                                  [excludePlusMinus]="true"
+                                  [label]="'TO' | coreLocalize"
+                                  [(model)]="sliderMax"
+                                  (focusout)="handleModelChange(sliderMax)"
+                          ></co-input-text>
+                      </div>
+                      <div class="co-filter-item-slider-content" *ngIf="mode === modes.NullableSlider">
+                          <co-input-text
+                                  class="slider-from"
+                                  [type]="'number'"
+                                  [digitsOnly]="true"
+                                  [hideArrowButtons]="true"
+                                  [excludePlusMinus]="true"
+                                  [label]="'FROM' | coreLocalize"
+                                  [(model)]="sliderMin"
+                                  (focusout)="handleModelChange(sliderMin)"
+                          ></co-input-text>
+                          <co-input-text
+                                  class="slider-to"
+                                  [type]="'number'"
+                                  [digitsOnly]="true"
+                                  [hideArrowButtons]="true"
+                                  [excludePlusMinus]="true"
+                                  [label]="'TO' | coreLocalize"
+                                  [(model)]="sliderMax"
+                                  (focusout)="handleModelChange(sliderMax)"
+                          ></co-input-text>
+                      </div>
+                      <div class="co-filter-item-checkbox-content" *ngIf="mode === modes.Checkbox ">
+                          <co-input-checkbox
+                                  [(model)]="model"
+                                  (modelChange)="handleModelChange($event)"
+                                  [label]="placeholder">
+                          </co-input-checkbox>
+                      </div>
+                      <div class="co-filter-item-checkbox-content"
+                           *ngIf="mode === modes.CheckboxToText || mode === modes.CheckboxToSimpleText || mode === modes.CheckboxToBinary">
+                          <co-input-checkbox
+                                  [(model)]="checkBoxToTextModel"
+                                  (modelChange)="handleModelChange($event)"
+                                  [label]="placeholder"></co-input-checkbox>
+                      </div>
+                      <div class="co-filter-item-textfield-content" *ngIf="mode === modes.TextField">
+                          <co-input-text
+                                  [(model)]="model"
+                                  (modelChange)="handleModelChange($event)"></co-input-text>
+                      </div>
+                      <div class="co-filter-item-dateField-content" *ngIf="mode === modes.DateField">
+                          <co-input-date
+                                  [(model)]="model"
+                                  (modelChange)="handleModelChange($event)"
+                          ></co-input-date>
+                      </div>
+                      <div class="co-filter-item-dateField-content" *ngIf="mode === modes.DateRangeField">
+                          <co-input-date-range
+                                  [model]="[dateRangeStart, dateRangeEnd]"
+                                  (modelChange)="handleModelChange($event)"
+                                  [placeholder]="'SELECT_DATE' | coreLocalize">
+                          </co-input-date-range>
+                      </div>
+                  </ng-template>
+              </div>
+          </co-collapsible>
+      </div>
+
+  `,
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush
+            },] }
+];
+FilterItemComponent.ctorParameters = () => [
+    { type: IconCacheService },
+    { type: ChangeDetectorRef }
+];
+FilterItemComponent.propDecorators = {
+    mode: [{ type: Input }],
+    collection: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    initialLimit: [{ type: Input }],
+    expanded: [{ type: Input }],
+    minSearchCharsToLoadCollection: [{ type: Input }],
+    collectionLoadFn: [{ type: Input }],
+    customContent: [{ type: Input }],
+    showAllResults: [{ type: Input }],
+    filterButtonLabel: [{ type: Input }],
+    searchPlaceholder: [{ type: Input }],
+    showMoreLabel: [{ type: Input }],
+    showLessLabel: [{ type: Input }],
+    noResultsLabel: [{ type: Input }],
+    sliderDefaultMin: [{ type: Input }],
+    sliderDefaultMax: [{ type: Input }],
+    fullRangeIsNull: [{ type: Input }],
+    model: [{ type: Input }],
+    modelChange: [{ type: Output }],
+    collectionChange: [{ type: Output }],
+    filterButtonClicked: [{ type: Output }],
+    filteredCollection: [{ type: HostBinding, args: ["class.co-filter-item",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-item.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/filter-item/filter-item.component.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,uBAAuB,EAAE,iBAAiB,EAC1C,SAAS,EACT,YAAY,EAAE,WAAW,EACzB,KAAK,EAEL,MAAM,EACN,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,kBAAkB,EAAC,MAAM,2CAA2C,CAAC;AAE7E,OAAO,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAC,cAAc,EAAC,MAAM,sCAAsC,CAAC;AA6JpE,MAAM,OAAO,mBAAmB;IAiH9B,YAAmB,WAA6B,EAC5B,eAAkC;QADnC,gBAAW,GAAX,WAAW,CAAkB;QAC5B,oBAAe,GAAf,eAAe,CAAmB;QAjH/C,UAAK,GAA8B,kBAAkB,CAAC;QACtD,UAAK,GAA0B,cAAc,CAAC;QA4B9C,iBAAY,GAAW,EAAE,CAAC;QAG1B,aAAQ,GAAY,KAAK,CAAC;QAQjC,4GAA4G;QAErG,kBAAa,GAAY,KAAK,CAAC;QAEtC,mHAAmH;QAE5G,mBAAc,GAAY,KAAK,CAAC;QAGhC,sBAAiB,GAAW,QAAQ,CAAC;QAGrC,sBAAiB,GAAW,WAAW,CAAC;QAGxC,kBAAa,GAAW,WAAW,CAAC;QAGpC,kBAAa,GAAW,WAAW,CAAC;QAGpC,mBAAc,GAAW,YAAY,CAAC;QAGtC,qBAAgB,GAAW,CAAC,CAAC;QAG7B,qBAAgB,GAAW,MAAM,CAAC;QAGlC,oBAAe,GAAY,KAAK,CAAC;QAYjC,gBAAW,GAAsB,IAAI,YAAY,EAAO,CAAC;QAGzD,qBAAgB,GAAwC,IAAI,YAAY,EAAyB,CAAC;QAGlG,wBAAmB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAInE,uBAAkB,GAA0B,EAAE,CAAC;QAC/C,YAAO,GAAW,EAAE,CAAC;QACrB,eAAU,GAAW,EAAE,CAAC;QACxB,eAAU,GAAY,KAAK,CAAC;QAa3B,gBAAW,GAA0B,EAAE,CAAC;QACxC,UAAK,GAAmB,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;IAKtD,CAAC;IA/GD,IACW,IAAI,CAAC,KAAqB;QACnC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IACW,UAAU,CAAC,KAA4B;;QAChD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,kBAAkB,GAAG,MAAA,IAAI,CAAC,WAAW,0CAAE,KAAK,EAAE,CAAC;QACpD,uFAAuF;QACvF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAiDD,IACW,KAAK,CAAC,QAAa;QAC5B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IAED,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAqCM,QAAQ;QACb,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACvC,IAAG,IAAI,CAAC,mBAAmB,KAAK,SAAS,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI,EAAE;YAC9E,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;SAClC;IACH,CAAC;IAEM,iBAAiB;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;IACnC,CAAC;IAEM,aAAa;QAClB,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC;IACrB,CAAC;IAEM,UAAU;;QACf,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,OAAO,KAAK,CAAC;SACd;QACD,OAAO,CAAA,MAAA,IAAI,CAAC,kBAAkB,0CAAE,MAAM,IAAG,IAAI,CAAC,OAAO,CAAC;IACxD,CAAC;IAEM,UAAU;;QACf,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,OAAO,KAAK,CAAC;SACd;QACD,OAAO,CAAA,MAAA,IAAI,CAAC,kBAAkB,0CAAE,MAAM,KAAI,IAAI,CAAC,OAAO,IAAI,CAAA,MAAA,IAAI,CAAC,kBAAkB,0CAAE,MAAM,IAAG,IAAI,CAAC,YAAY,CAAC;IAChH,CAAC;IAEM,iBAAiB,CAAC,KAAU;QACjC,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,IAAI,CAAC,KAAK,CAAC,UAAU;gBACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,KAAK,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;gBAC/B,IAAI,CAAC,yBAAyB,EAAE,CAAC;gBACjC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,oCAAoC;gBAClD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,KAAK,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;gBAC/B,IAAI,CAAC,mCAAmC,EAAE,CAAC;gBAC3C,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,gBAAgB;gBAC9B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;gBACnC,KAAK,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;gBAC/B,IAAI,CAAC,+BAA+B,EAAE,CAAC;gBACvC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,0BAA0B;gBACxC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,KAAK,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;gBAC/B,IAAI,CAAC,yCAAyC,EAAE,CAAC;gBACjD,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM;gBACpB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,yBAAyB,EAAE,CAAC;gBACjC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,iCAAiC,EAAE,CAAC;gBACzC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,6BAA6B,EAAE,CAAC;gBACrC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,oBAAoB;gBAClC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,mCAAmC,EAAE,CAAC;gBAC3C,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,gBAAgB;gBAC9B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,+BAA+B,EAAE,CAAC;gBACvC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;gBACrC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,SAAS;gBACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACvB,IAAI,CAAC,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;gBACtG,MAAM;SACT;QACD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAEM,aAAa;QAClB,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;SAC/C;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,oCAAoC;IACvB,WAAW,CAAC,IAAY;;;YACnC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE;gBACxE,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,8BAA8B,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;oBAC/F,IAAI,CAAC,UAAU,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;iBACrD;qBAAM,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,8BAA8B,EAAE;oBAC5D,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;iBAC7B;aACF;YACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;gBACpB,OAAO,EAAE,CAAC;aACX;YAED,MAAM,UAAU,GAAW,MAAA,IAAI,CAAC,UAAU,0CAAE,QAAQ,GAAG,WAAW,EAAE,CAAC;YACrE,IAAI,iBAAiB,GAAW,CAAC,CAAC;YAClC,IAAI,CAAC,kBAAkB,GAAG,MAAA,IAAI,CAAC,UAAU,0CAAE,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;;gBACzD,MAAM,SAAS,GAAW,MAAA,IAAI,CAAC,WAAW,0CAAE,QAAQ,GAAG,WAAW,EAAE,CAAC;gBACrE,MAAM,gBAAgB,GAAY,CAAC,CAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,OAAO,CAAC,UAAU,CAAC,MAAK,CAAC,CAAC,CAAC,CAAC;gBAC1E,IAAI,gBAAgB,EAAE;oBACpB,OAAO,KAAK,CAAC;iBACd;qBAAM;oBACL,iBAAiB,EAAE,CAAC;oBACpB,OAAO,IAAI,CAAC;iBACb;YACH,CAAC,CAAC,CAAC;;KACJ;IAEM,eAAe;QACpB,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,CAAC;IAClC,CAAC;IAEO,sBAAsB,CAAC,KAA0B;QACvD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YAC1B,IAAI,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,WAAW,KAAK,KAAK,CAAC,WAAW,EAAE;gBAChE,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;aACnB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,gBAAgB,CAAC,QAAa;QACpC,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,IAAI,CAAC,KAAK,CAAC,UAAU;gBACxB,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;gBACvC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,gBAAgB;gBAC9B,IAAI,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC;gBAC7C,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,oCAAoC;gBAClD,IAAI,CAAC,iCAAiC,CAAC,QAAQ,CAAC,CAAC;gBACjD,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,0BAA0B;gBACxC,IAAI,CAAC,uCAAuC,CAAC,QAAQ,CAAC,CAAC;gBACvD,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YACvB,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC5B,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;gBACvC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;YAC/B,KAAK,IAAI,CAAC,KAAK,CAAC,oBAAoB;gBAClC,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC;gBAC3C,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,gBAAgB;gBAC9B,IAAI,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC;gBAC7C,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,SAAS;gBACvB,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;gBACtC,MAAM;YACR,KAAK,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC5B,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC;gBAC3C,MAAM;YACR;gBACE,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;SAC1B;IACH,CAAC;IACD,6DAA6D;IAC7D,6DAA6D;IAC7D,6DAA6D;IACrD,yBAAyB;QAC/B,IAAI,WAAW,GAAa,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAC7D,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;gBACzD,IAAI,SAAS,CAAC,OAAO,EAAE;oBACrB,WAAW,CAAC,IAAI,CAAC,MAAM,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC;iBAC3C;YACH,CAAC,CAAC,CAAC;YACH,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC1B,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACrC;iBAAM;gBACL,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;aACzB;SACF;IACH,CAAC;IAEO,mCAAmC;QACzC,IAAI,WAAW,GAAa,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;YACzD,IAAI,SAAS,CAAC,OAAO,EAAE;gBACrB,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;aAC7C;QACH,CAAC,CAAC,CAAC;QACH,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;SAC3B;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;SACzB;IACH,CAAC;IAEO,+BAA+B;QACrC,IAAI,YAAY,GAAW,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;YACzD,IAAI,SAAS,CAAC,OAAO,EAAE;gBACrB,YAAY,GAAG,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;aAC1C;QACH,CAAC,CAAC,CAAC;QACH,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC;SAC5B;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;SACzB;IACH,CAAC;IAEO,yCAAyC;QAC/C,IAAI,YAAY,GAAW,IAAI,CAAC;QAChC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;YACzD,IAAI,SAAS,CAAC,OAAO,EAAE;gBACrB,IAAI,YAAY,IAAI,IAAI,EAAE;oBACxB,YAAY,GAAG,CAAC,CAAC;iBAClB;gBACD,YAAY,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;aACxC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC;IAC7B,CAAC;IAEO,yBAAyB;QAC/B,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAC3E,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAE3E,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAE9D,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG,GAAG,cAAc,MAAM,cAAc,EAAE,CAAC;IAExD,CAAC;IAEO,iCAAiC;QAEvC,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,EAAE;YACpC,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAC9D,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAE9D,IAAI,CAAC,MAAM,GAAG,GAAG,cAAc,MAAM,cAAc,EAAE,CAAC;SACvD;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;SACpB;IACH,CAAC;IAEO,6BAA6B;QACnC,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;SACvB;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;SACvB;IACH,CAAC;IAEO,mCAAmC;QACzC,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;SACnB;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;SACnB;IACH,CAAC;IAEO,+BAA+B;QACrC,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;SACjB;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;SACjB;IACH,CAAC;IAEO,wBAAwB,CAAC,KAAa;QAC5C,IAAI,KAAK,EAAE;YACT,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAEvB,MAAM,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9E,MAAM,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAExE,IAAI,CAAC,MAAM,GAAG,QAAQ,gBAAgB,YAAY,cAAc,IAAI,CAAC;SACtE;IACH,CAAC;IAEO,mBAAmB,CAAC,IAAU;QACpC,IAAI,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACrD,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9D,IAAI,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAE9B,OAAO,GAAG,GAAG,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;IACnC,CAAC;IAED,4DAA4D;IAC5D,4DAA4D;IAC5D,4DAA4D;IACpD,uBAAuB,CAAC,WAAmB;QACjD,IAAI,UAAU,GAAa,EAAE,CAAC;QAC9B,IAAI,YAAY,GAAa,EAAE,CAAC;QAChC,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;QAE1B,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,SAAS,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAChL,UAAU,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACnC,UAAU,CAAC,OAAO,CAAC,CAAC,MAAc,EAAE,EAAE;gBACpC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACzD,CAAC,CAAC,CAAC;YAEH,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE;gBAC/B,IAAI,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC,CAAC;gBAC/E,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE;oBAC3C,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;iBACvB;aACF;YACD,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;SAC3B;IAEH,CAAC;IAEO,6BAA6B,CAAC,iBAAyB;QAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,iBAAiB,CAAC;QAEhC,IAAI,iBAAiB,KAAK,IAAI,IAAI,iBAAiB,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAC9H,IAAI,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,iBAAiB,CAAC,CAAC;YAC5F,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE;gBAC3C,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;aACvB;SACF;IACH,CAAC;IAEO,iCAAiC,CAAC,eAAyB;QACjE,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC;QAE9B,IAAI,eAAe,KAAK,IAAI,IAAI,eAAe,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAC1H,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAA8B,EAAE,EAAE;gBACzD,IAAI,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE;oBAC3D,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;iBAC1B;qBAAM;oBACL,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC;iBAC3B;YACH,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAEO,uCAAuC,CAAC,WAAmB;QACjE,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;QAE1B,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAClH,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE;gBAClC,MAAM,QAAQ,GAAW,IAAI,CAAC,IAAc,CAAC;gBAC7C,MAAM,QAAQ,GAAG,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;gBAChD,IAAI,CAAC,OAAO,GAAG,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAC;aACvC;SACF;IACH,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAC7D,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC1B,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;YACpB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAEO,uBAAuB,CAAC,WAAmB;QACjD,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;QAC1B,IAAI,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,IAAI,EAAE;YACrD,IAAI,qBAAqB,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;SACrD;aAAM;YACL,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC;YACvC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC;SACxC;IACH,CAAC;IAEO,2BAA2B,CAAC,mBAA2B;QAC7D,IAAI,CAAC,MAAM,GAAG,mBAAmB,CAAC;QAClC,IAAI,mBAAmB,KAAK,SAAS,IAAI,mBAAmB,KAAK,IAAI,EAAE;YACrE,IAAI,CAAC,mBAAmB,GAAG,CAAC,mBAAmB,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;SACpE;aAAM;YACL,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;SAClC;IACH,CAAC;IAEO,6BAA6B,CAAC,gBAAwB;QAC5D,IAAI,CAAC,MAAM,GAAG,gBAAgB,CAAC;QAC/B,IAAI,gBAAgB,KAAK,SAAS,IAAI,gBAAgB,KAAK,IAAI,EAAE;YAC/D,IAAI,CAAC,mBAAmB,GAAG,CAAC,gBAAgB,IAAI,CAAC,CAAC,CAAC;SACpD;aAAM;YACL,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;SAClC;IACH,CAAC;IAEO,sBAAsB,CAAC,cAAsB;QACnD,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;QAC7B,IAAI,cAAc,KAAK,SAAS,IAAI,cAAc,KAAK,IAAI,EAAE;YAC3D,IAAI,CAAC,MAAM,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC;SACxC;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;SACzB;IACH,CAAC;IAEO,2BAA2B,CAAC,mBAA2B;QAC7D,IAAI,CAAC,MAAM,GAAG,mBAAmB,CAAC;QAClC,IAAI,mBAAmB,KAAK,SAAS,IAAI,mBAAmB,KAAK,IAAI,EAAE;YACrE,IAAI,cAAc,GAAG,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAEpD,IAAI,WAAW,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACnF,IAAI,SAAS,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAEjF,IAAI,mBAAmB,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACjD,IAAI,iBAAiB,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAE7C,IAAI,CAAC,cAAc,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACzI,IAAI,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAClI;aAAM;YACL,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;SAC/B;IACH,CAAC;;;YA3rBF,SAAS,SAAC;gBACT,QAAQ,EAAE,gBAAgB;gBAC1B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqJT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBACrC,eAAe,EAAE,uBAAuB,CAAC,MAAM;aAChD;;;YA7JO,gBAAgB;YAVG,iBAAiB;;;mBA4KzC,KAAK;yBAUL,KAAK;0BAYL,KAAK;2BAGL,KAAK;uBAGL,KAAK;6CAGL,KAAK;+BAGL,KAAK;4BAIL,KAAK;6BAIL,KAAK;gCAGL,KAAK;gCAGL,KAAK;4BAGL,KAAK;4BAGL,KAAK;6BAGL,KAAK;+BAGL,KAAK;+BAGL,KAAK;8BAGL,KAAK;oBAGL,KAAK;0BASL,MAAM;+BAGN,MAAM;kCAGN,MAAM;iCAGN,WAAW,SAAC,sBAAsB","sourcesContent":["import {\r\n  ChangeDetectionStrategy, ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter, HostBinding,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport {CoreComponentsIcon} from '../../core/enum/core-components-icon.enum';\r\nimport {FilterItemViewmodel} from './filter-item-viewmodel';\r\nimport {IconCacheService} from '../icon/icon-cache.service';\r\nimport {FilterItemMode} from '../../core/enum/filterItem-mode.enum';\r\n\r\n@Component({\r\n  selector: \"co-filter-item\",\r\n  template: `\r\n      <div class=\"co-filter-item-header\">\r\n          <co-collapsible\r\n                  [headerTitle]=\"placeholder\"\r\n                  [expandButtonLast]=\"true\"\r\n                  [iconData]=\"iconService.getIcon(icons.ArrowPointDown)\"\r\n                  [expanded]=\"expanded\"\r\n                  [showButton]=\"showButton\"\r\n                  [buttonText]=\"filterButtonLabel\"\r\n                  (buttonClicked)=\"onButtonClicked()\"\r\n          >\r\n              <div class=\"co-filter-item-collapsable-content\">\r\n                  <div class=\"co-filter-item-custom-content\" *ngIf=\"customContent; else collectionContent\"\r\n                       (keydown)=\"showButton=true\" (mousedown)=\"showButton=true\">\r\n                      <ng-content></ng-content>\r\n                  </div>\r\n                  <ng-template #collectionContent>\r\n                      <div class=\"co-filter-item-collection-content\" *ngIf=\"mode === modes.Filterlist || mode === modes.SingleSelectList\r\n                                                                   || mode === modes.SelectListWithNumberOutput || mode === modes.SelectListWithStringCollectionOutput\">\r\n                          <co-input-text\r\n                                  *ngIf=\"collection?.length > 10 || minSearchCharsToLoadCollection\"\r\n                                  [placeholder]=\"searchPlaceholder\"\r\n                                  [model]=\"filterText\"\r\n                                  (modelChange)=\"applyFilter($event)\"\r\n                          >\r\n                          </co-input-text>\r\n                          <div class=\"no-results\" *ngIf=\"filteredCollection?.length === 0\">\r\n                              <span [textContent]=\"noResultsLabel\"></span>\r\n                          </div>\r\n                          <div class=\"co-filter-item-collection-results\">\r\n                              <ng-container\r\n                                      *ngFor=\"let option of filteredCollection; let index = index\">\r\n                                  <div class=\"co-filter-item-collection-result-item\" *ngIf=\"index < limitTo || showAllResults\">\r\n                                      <co-input-checkbox *ngIf=\"mode !== modes.SingleSelectList\"\r\n                                                         [label]=\"option.description\"\r\n                                                         [model]=\"option.checked\"\r\n                                                         [clickableLabel]=\"false\"\r\n                                                         (modelChange)=\"handleModelChange(option)\"\r\n                                      ></co-input-checkbox>\r\n                                      <co-input-radio-button *ngIf=\"mode === modes.SingleSelectList\"\r\n                                                             [label]=\"option.description\"\r\n                                                             [model]=\"option.checked\"\r\n                                                             (modelChange)=\"handleModelChange(option)\"\r\n                                      ></co-input-radio-button>\r\n                                      <div class=\"co-filter-item-amount\" *ngIf=\"option.count\"\r\n                                           [textContent]=\"option.count.toString() | append: ')' | prepend: '      ('\"\r\n                                      ></div>\r\n                                  </div>\r\n\r\n                              </ng-container>\r\n                          </div>\r\n                          <div class=\"co-filter-show-more-or-less\" *ngIf=\"!showAllResults\">\r\n                              <div class=\"co-filter-show-more clickable\"\r\n                                   *ngIf=\"moreToShow()\">\r\n                                  <a (click)=\"increaseLimit()\">\r\n                                      <co-icon [iconData]=\"iconService.getIcon(icons.ArrowPointDown)\"></co-icon>\r\n                                      <span [textContent]=\"showMoreLabel\"></span>\r\n                                  </a>\r\n                              </div>\r\n                              <div class=\"co-filter-show-less clickable\"\r\n                                   *ngIf=\"lessToShow()\">\r\n                                  <a (click)=\"setToInitialLimit()\">\r\n                                      <co-icon [iconData]=\"iconService.getIcon(icons.ArrowPointUp)\"></co-icon>\r\n                                      <span [textContent]=\"showLessLabel\"></span>\r\n                                  </a>\r\n                              </div>\r\n                          </div>\r\n                      </div>\r\n                      <div class=\"co-filter-item-slider-content\" *ngIf=\"mode === modes.Slider\">\r\n                          <co-input-text\r\n                                  class=\"slider-from\"\r\n                                  [type]=\"'number'\"\r\n                                  [digitsOnly]=\"true\"\r\n                                  [hideArrowButtons]=\"true\"\r\n                                  [excludePlusMinus]=\"true\"\r\n                                  [label]=\"'FROM' | coreLocalize\"\r\n                                  [(model)]=\"sliderMin\"\r\n                                  (focusout)=\"handleModelChange(sliderMin)\"\r\n                          ></co-input-text>\r\n                          <co-input-text\r\n                                  class=\"slider-to\"\r\n                                  [type]=\"'number'\"\r\n                                  [digitsOnly]=\"true\"\r\n                                  [hideArrowButtons]=\"true\"\r\n                                  [excludePlusMinus]=\"true\"\r\n                                  [label]=\"'TO' | coreLocalize\"\r\n                                  [(model)]=\"sliderMax\"\r\n                                  (focusout)=\"handleModelChange(sliderMax)\"\r\n                          ></co-input-text>\r\n                      </div>\r\n                      <div class=\"co-filter-item-slider-content\" *ngIf=\"mode === modes.NullableSlider\">\r\n                          <co-input-text\r\n                                  class=\"slider-from\"\r\n                                  [type]=\"'number'\"\r\n                                  [digitsOnly]=\"true\"\r\n                                  [hideArrowButtons]=\"true\"\r\n                                  [excludePlusMinus]=\"true\"\r\n                                  [label]=\"'FROM' | coreLocalize\"\r\n                                  [(model)]=\"sliderMin\"\r\n                                  (focusout)=\"handleModelChange(sliderMin)\"\r\n                          ></co-input-text>\r\n                          <co-input-text\r\n                                  class=\"slider-to\"\r\n                                  [type]=\"'number'\"\r\n                                  [digitsOnly]=\"true\"\r\n                                  [hideArrowButtons]=\"true\"\r\n                                  [excludePlusMinus]=\"true\"\r\n                                  [label]=\"'TO' | coreLocalize\"\r\n                                  [(model)]=\"sliderMax\"\r\n                                  (focusout)=\"handleModelChange(sliderMax)\"\r\n                          ></co-input-text>\r\n                      </div>\r\n                      <div class=\"co-filter-item-checkbox-content\" *ngIf=\"mode === modes.Checkbox \">\r\n                          <co-input-checkbox\r\n                                  [(model)]=\"model\"\r\n                                  (modelChange)=\"handleModelChange($event)\"\r\n                                  [label]=\"placeholder\">\r\n                          </co-input-checkbox>\r\n                      </div>\r\n                      <div class=\"co-filter-item-checkbox-content\"\r\n                           *ngIf=\"mode === modes.CheckboxToText || mode === modes.CheckboxToSimpleText || mode === modes.CheckboxToBinary\">\r\n                          <co-input-checkbox\r\n                                  [(model)]=\"checkBoxToTextModel\"\r\n                                  (modelChange)=\"handleModelChange($event)\"\r\n                                  [label]=\"placeholder\"></co-input-checkbox>\r\n                      </div>\r\n                      <div class=\"co-filter-item-textfield-content\" *ngIf=\"mode === modes.TextField\">\r\n                          <co-input-text\r\n                                  [(model)]=\"model\"\r\n                                  (modelChange)=\"handleModelChange($event)\"></co-input-text>\r\n                      </div>\r\n                      <div class=\"co-filter-item-dateField-content\" *ngIf=\"mode === modes.DateField\">\r\n                          <co-input-date\r\n                                  [(model)]=\"model\"\r\n                                  (modelChange)=\"handleModelChange($event)\"\r\n                          ></co-input-date>\r\n                      </div>\r\n                      <div class=\"co-filter-item-dateField-content\" *ngIf=\"mode === modes.DateRangeField\">\r\n                          <co-input-date-range\r\n                                  [model]=\"[dateRangeStart, dateRangeEnd]\"\r\n                                  (modelChange)=\"handleModelChange($event)\"\r\n                                  [placeholder]=\"'SELECT_DATE' | coreLocalize\">\r\n                          </co-input-date-range>\r\n                      </div>\r\n                  </ng-template>\r\n              </div>\r\n          </co-collapsible>\r\n      </div>\r\n\r\n  `,\r\n  encapsulation: ViewEncapsulation.None,\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class FilterItemComponent implements OnInit {\r\n  public icons: typeof CoreComponentsIcon = CoreComponentsIcon;\r\n  public modes: typeof FilterItemMode = FilterItemMode;\r\n\r\n  @Input()\r\n  public set mode(value: FilterItemMode) {\r\n    this._mode = value;\r\n    this.readModelForMode(this._model);\r\n  }\r\n\r\n  public get mode(): FilterItemMode {\r\n    return this._mode;\r\n  }\r\n\r\n  @Input()\r\n  public set collection(value: FilterItemViewmodel[]) {\r\n    this._collection = value;\r\n    this.filteredCollection = this._collection?.slice();\r\n    //reset the model in case there was no collection to set its values on when it was set.\r\n    this.model = this._model;\r\n  }\r\n\r\n  public get collection(): FilterItemViewmodel[] {\r\n    return this._collection;\r\n  }\r\n\r\n  @Input()\r\n  public placeholder: string;\r\n\r\n  @Input()\r\n  public initialLimit: number = 10;\r\n\r\n  @Input()\r\n  public expanded: boolean = false;\r\n\r\n  @Input()\r\n  public minSearchCharsToLoadCollection: number;\r\n\r\n  @Input()\r\n  public collectionLoadFn: Function;\r\n\r\n  // Set to false to use filter item with a multi selectable collection. Set to true to specify custom content\r\n  @Input()\r\n  public customContent: boolean = false;\r\n\r\n  // Set to true to show all results. Set to false to get 'show more' and 'show less' buttons to expand and contract.\r\n  @Input()\r\n  public showAllResults: boolean = false;\r\n\r\n  @Input()\r\n  public filterButtonLabel: string = \"Search\";\r\n\r\n  @Input()\r\n  public searchPlaceholder: string = 'Search...';\r\n\r\n  @Input()\r\n  public showMoreLabel: string = 'Show more';\r\n\r\n  @Input()\r\n  public showLessLabel: string = 'Show less';\r\n\r\n  @Input()\r\n  public noResultsLabel: string = \"No results\";\r\n\r\n  @Input()\r\n  public sliderDefaultMin: number = 0;\r\n\r\n  @Input()\r\n  public sliderDefaultMax: number = 100000;\r\n\r\n  @Input()\r\n  public fullRangeIsNull: boolean = false;\r\n\r\n  @Input()\r\n  public set model(newModel: any) {\r\n    this.readModelForMode(newModel);\r\n  }\r\n\r\n  public get model(): any {\r\n    return this._model;\r\n  }\r\n\r\n  @Output()\r\n  public modelChange: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n  @Output()\r\n  public collectionChange: EventEmitter<FilterItemViewmodel[]> = new EventEmitter<FilterItemViewmodel[]>();\r\n\r\n  @Output()\r\n  public filterButtonClicked: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  @HostBinding(\"class.co-filter-item\")\r\n\r\n  public filteredCollection: FilterItemViewmodel[] = [];\r\n  public limitTo: number = 10;\r\n  public filterText: string = \"\";\r\n  public showButton: boolean = false;\r\n\r\n  //models for the slider field inputs\r\n  public sliderMin: number;\r\n  public sliderMax: number;\r\n\r\n  //models for th daterange input\r\n  public dateRangeStart: Date;\r\n  public dateRangeEnd: Date;\r\n\r\n  //model for the textbox options that need a converted output\r\n  public checkBoxToTextModel: boolean;\r\n\r\n  private _collection: FilterItemViewmodel[] = [];\r\n  private _mode: FilterItemMode = this.modes.Filterlist;\r\n  private _model: any;\r\n\r\n  constructor(public iconService: IconCacheService,\r\n              private _changeDetector: ChangeDetectorRef) {\r\n  }\r\n\r\n  public ngOnInit(): void {\r\n    this.setToInitialLimit();\r\n    this.showButton = this.valueSelected();\r\n    if(this.checkBoxToTextModel === undefined || this.checkBoxToTextModel === null) {\r\n      this.checkBoxToTextModel = false;\r\n    }\r\n  }\r\n\r\n  public setToInitialLimit(): void {\r\n    this.limitTo = this.initialLimit;\r\n  }\r\n\r\n  public increaseLimit(): void {\r\n    this.limitTo += 10;\r\n  }\r\n\r\n  public moreToShow(): boolean {\r\n    if (this.showAllResults) {\r\n      return false;\r\n    }\r\n    return this.filteredCollection?.length > this.limitTo;\r\n  }\r\n\r\n  public lessToShow() {\r\n    if (this.showAllResults) {\r\n      return false;\r\n    }\r\n    return this.filteredCollection?.length <= this.limitTo && this.filteredCollection?.length > this.initialLimit;\r\n  }\r\n\r\n  public handleModelChange(model: any) {\r\n    switch (this.mode) {\r\n      case this.modes.Filterlist:\r\n        this.showButton = true;\r\n        model.checked = !model.checked;\r\n        this._createModelForFilterList();\r\n        break;\r\n      case this.modes.SelectListWithStringCollectionOutput:\r\n        this.showButton = true;\r\n        model.checked = !model.checked;\r\n        this._createModelForStringCollectionList();\r\n        break;\r\n      case this.modes.SingleSelectList:\r\n        this.showButton = true;\r\n        this.uncheckForSingleSelect(model);\r\n        model.checked = !model.checked;\r\n        this._createModelForSingleSelectList();\r\n        break;\r\n      case this.modes.SelectListWithNumberOutput:\r\n        this.showButton = true;\r\n        model.checked = !model.checked;\r\n        this._createModelForSelectListWithNumberOutput();\r\n        break;\r\n      case this.modes.Slider:\r\n        this.showButton = true;\r\n        this._createModelForSliderMode();\r\n        break;\r\n      case this.modes.NullableSlider:\r\n        this.showButton = true;\r\n        this._createModelForNullableSliderMode();\r\n        break;\r\n      case this.modes.CheckboxToText:\r\n        this.showButton = true;\r\n        this._createModelForCheckboxToText();\r\n        break;\r\n      case this.modes.CheckboxToSimpleText:\r\n        this.showButton = true;\r\n        this._createModelForCheckboxToSimpleText();\r\n        break;\r\n      case this.modes.CheckboxToBinary:\r\n        this.showButton = true;\r\n        this._createModelForCheckboxToBinary();\r\n        break;\r\n      case this.modes.DateRangeField:\r\n        this.showButton = true;\r\n        this._createModelForDateRange(model);\r\n        break;\r\n      case this.modes.TextField:\r\n        this.showButton = true;\r\n        this._model = (typeof this._model === 'string' && this._model.length === 0) ? undefined : this._model;\r\n        break;\r\n    }\r\n    this.modelChange.emit(this._model);\r\n    this.collectionChange.emit(this.collection);\r\n  }\r\n\r\n  public valueSelected() {\r\n    if (this.collection) {\r\n      return !!this.collection.find(c => c.checked);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  // Applies filter to the collection.\r\n  public async applyFilter(text: string): Promise<[]> {\r\n    if (!isNaN(this.minSearchCharsToLoadCollection) && this.collectionLoadFn) {\r\n      if (text.length === this.minSearchCharsToLoadCollection && text.length > this.filterText.length) {\r\n        this.collection = await this.collectionLoadFn(text);\r\n      } else if (text.length < this.minSearchCharsToLoadCollection) {\r\n        this.collection = undefined;\r\n      }\r\n    }\r\n    this.filterText = text;\r\n    if (!this.collection) {\r\n      return [];\r\n    }\r\n\r\n    const filterText: string = this.filterText?.toString().toLowerCase();\r\n    let filteredItemCount: number = 0;\r\n    this.filteredCollection = this.collection?.filter((item) => {\r\n      const labelText: string = item.description?.toString().toLowerCase();\r\n      const isHiddenByFilter: boolean = (labelText?.indexOf(filterText) === -1);\r\n      if (isHiddenByFilter) {\r\n        return false;\r\n      } else {\r\n        filteredItemCount++;\r\n        return true;\r\n      }\r\n    });\r\n  }\r\n\r\n  public onButtonClicked(): void {\r\n    this.filterButtonClicked.emit();\r\n  }\r\n\r\n  private uncheckForSingleSelect(model: FilterItemViewmodel): void {\r\n    this.collection.forEach(m => {\r\n      if (m.code !== model.code && m.description !== model.description) {\r\n        m.checked = false;\r\n      }\r\n    });\r\n  }\r\n\r\n  private readModelForMode(newModel: any): void {\r\n    switch (this.mode) {\r\n      case this.modes.Filterlist:\r\n        this._readModelForFilterList(newModel);\r\n        break;\r\n      case this.modes.SingleSelectList:\r\n        this._readModelForSingleSelectList(newModel);\r\n        break;\r\n      case this.modes.SelectListWithStringCollectionOutput:\r\n        this._readModelForStringCollectionList(newModel);\r\n        break;\r\n      case this.modes.SelectListWithNumberOutput:\r\n        this._readModelForSelectListWithNumberOutput(newModel);\r\n        break;\r\n      case this.modes.Slider:\r\n      case this.modes.NullableSlider:\r\n        this._readModelForSliderMode(newModel);\r\n        break;\r\n      case this.modes.CheckboxToText:\r\n      case this.modes.CheckboxToSimpleText:\r\n        this._readModelForCheckboxToText(newModel);\r\n        break;\r\n      case this.modes.CheckboxToBinary:\r\n        this._readModelForCheckboxToBinary(newModel);\r\n        break;\r\n      case this.modes.DateField:\r\n        this._readModelForDateField(newModel);\r\n        break;\r\n      case this.modes.DateRangeField:\r\n        this._readModelForDateRangeField(newModel);\r\n        break;\r\n      default:\r\n        this._model = newModel;\r\n    }\r\n  }\r\n  /////////////////////////////////////////////////////////////\r\n  //Model creation for all of the different options available//\r\n  /////////////////////////////////////////////////////////////\r\n  private _createModelForFilterList(): void {\r\n    let filterRange: string[] = [];\r\n    if (this.collection !== null && this.collection !== undefined) {\r\n      this.collection.forEach((viewModel: FilterItemViewmodel) => {\r\n        if (viewModel.checked) {\r\n          filterRange.push(`?='${viewModel.code}'`);\r\n        }\r\n      });\r\n      if (filterRange.length > 0) {\r\n        this._model = filterRange.join(',');\r\n      } else {\r\n        this._model = undefined;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _createModelForStringCollectionList(): void {\r\n    let filterRange: string[] = [];\r\n    this.collection.forEach((viewModel: FilterItemViewmodel) => {\r\n      if (viewModel.checked) {\r\n        filterRange.push(viewModel.code.toString());\r\n      }\r\n    });\r\n    if (filterRange.length > 0) {\r\n      this._model = filterRange;\r\n    } else {\r\n      this._model = undefined;\r\n    }\r\n  }\r\n\r\n  private _createModelForSingleSelectList(): void {\r\n    let filterString: string = \"\";\r\n    this.collection.forEach((viewModel: FilterItemViewmodel) => {\r\n      if (viewModel.checked) {\r\n        filterString = viewModel.code.toString();\r\n      }\r\n    });\r\n    if (filterString.length > 0) {\r\n      this._model = filterString;\r\n    } else {\r\n      this._model = undefined;\r\n    }\r\n  }\r\n\r\n  private _createModelForSelectListWithNumberOutput(): void {\r\n    let filterNumber: number = null;\r\n    this.collection.forEach((viewModel: FilterItemViewmodel) => {\r\n      if (viewModel.checked) {\r\n        if (filterNumber == null) {\r\n          filterNumber = 0;\r\n        }\r\n        filterNumber += Number(viewModel.code);\r\n      }\r\n    });\r\n    this._model = filterNumber;\r\n  }\r\n\r\n  private _createModelForSliderMode(): void {\r\n    this.sliderMin = !!this.sliderMin ? this.sliderMin : this.sliderDefaultMin;\r\n    this.sliderMax = !!this.sliderMax ? this.sliderMax : this.sliderDefaultMax;\r\n\r\n    let trueLowerBound = Math.min(this.sliderMin, this.sliderMax);\r\n    let trueUpperBound = Math.max(this.sliderMin, this.sliderMax);\r\n\r\n    this.sliderMin = trueLowerBound;\r\n    this.sliderMax = trueUpperBound;\r\n    this._model = `${trueLowerBound} - ${trueUpperBound}`;\r\n\r\n  }\r\n\r\n  private _createModelForNullableSliderMode(): void {\r\n\r\n    if (this.sliderMin && this.sliderMax) {\r\n      let trueLowerBound = Math.min(this.sliderMin, this.sliderMax);\r\n      let trueUpperBound = Math.max(this.sliderMin, this.sliderMax);\r\n\r\n      this._model = `${trueLowerBound} - ${trueUpperBound}`;\r\n    } else {\r\n      this._model = null;\r\n    }\r\n  }\r\n\r\n  private _createModelForCheckboxToText(): void {\r\n    if (this.checkBoxToTextModel) {\r\n      this._model = \"?='J'\";\r\n    } else {\r\n      this._model = \"?='N'\";\r\n    }\r\n  }\r\n\r\n  private _createModelForCheckboxToSimpleText(): void {\r\n    if (this.checkBoxToTextModel) {\r\n      this._model = \"J\";\r\n    } else {\r\n      this._model = \"N\";\r\n    }\r\n  }\r\n\r\n  private _createModelForCheckboxToBinary(): void {\r\n    if (this.checkBoxToTextModel) {\r\n      this._model = 1;\r\n    } else {\r\n      this._model = 0;\r\n    }\r\n  }\r\n\r\n  private _createModelForDateRange(dates: Date[]): void {\r\n    if (dates) {\r\n      let startDate = dates[0];\r\n      let endDate = dates[1];\r\n\r\n      const startDateRequest = startDate ? this._formatDateToString(startDate) : '';\r\n      const endDateRequest = endDate ? this._formatDateToString(endDate) : '';\r\n\r\n      this._model = `?>=\\'${startDateRequest}\\'& ?<=\\'${endDateRequest}\\'`;\r\n    }\r\n  }\r\n\r\n  private _formatDateToString(date: Date): string {\r\n    let day = date.getDate().toString().padStart(2, '0');\r\n    let month = (date.getMonth() + 1).toString().padStart(2, '0');\r\n    let year = date.getFullYear();\r\n\r\n    return `${day}-${month}-${year}`;\r\n  }\r\n\r\n  ////////////////////////////////////////////////////////////\r\n  //Model reading for all of the different options available//\r\n  ////////////////////////////////////////////////////////////\r\n  private _readModelForFilterList(filterModel: string): void {\r\n    let filterList: string[] = [];\r\n    let itemsToCheck: string[] = [];\r\n    this._uncheckAll();\r\n    this._model = filterModel;\r\n\r\n    if (filterModel !== null && filterModel !== undefined && typeof filterModel === 'string' && filterModel.length != 0 && this.collection !== null && this.collection !== undefined) {\r\n      filterList = filterModel.split(\",\")\r\n      filterList.forEach((filter: string) => {\r\n        itemsToCheck.push(filter.substr(3, filter.length - 4));\r\n      });\r\n\r\n      for (const item of itemsToCheck) {\r\n        let filter = this.collection.find(element => element.code.toString() === item);\r\n        if (filter !== null && filter !== undefined) {\r\n          filter.checked = true;\r\n        }\r\n      }\r\n      this._model = filterModel;\r\n    }\r\n\r\n  }\r\n\r\n  private _readModelForSingleSelectList(singleSelectModel: string) {\r\n    this._uncheckAll();\r\n    this._model = singleSelectModel;\r\n\r\n    if (singleSelectModel !== null && singleSelectModel !== undefined && this.collection !== null && this.collection !== undefined) {\r\n      let filter = this.collection.find(element => element.code.toString() === singleSelectModel);\r\n      if (filter !== null && filter !== undefined) {\r\n        filter.checked = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  private _readModelForStringCollectionList(collectionModel: string[]): void {\r\n    this._uncheckAll();\r\n    this._model = collectionModel;\r\n\r\n    if (collectionModel !== null && collectionModel !== undefined && this.collection !== null && this.collection !== undefined) {\r\n      this.collection.forEach((viewModel: FilterItemViewmodel) => {\r\n        if (collectionModel.indexOf(viewModel.code.toString()) > -1) {\r\n          viewModel.checked = true;\r\n        } else {\r\n          viewModel.checked = false;\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  private _readModelForSelectListWithNumberOutput(numberModel: number) {\r\n    this._uncheckAll();\r\n    this._model = numberModel;\r\n\r\n    if (numberModel !== null && numberModel !== undefined && this.collection !== null && this.collection !== undefined) {\r\n      for (const item of this.collection) {\r\n        const itemCode: number = item.code as number;\r\n        const modValue = (numberModel % (2 * itemCode));\r\n        item.checked = (modValue >= itemCode);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _uncheckAll() {\r\n    if (this.collection !== null && this.collection !== undefined) {\r\n      this.collection.forEach(m => {\r\n        m.checked = false;\r\n      });\r\n    }\r\n  }\r\n\r\n  private _readModelForSliderMode(sliderModel: string): void {\r\n    this._model = sliderModel;\r\n    if (sliderModel !== undefined && sliderModel !== null) {\r\n      let sliderInputCollection = sliderModel.split(' - ');\r\n      this.sliderMin = parseInt(sliderInputCollection[0]);\r\n      this.sliderMax = parseInt(sliderInputCollection[1]);\r\n    } else {\r\n      this.sliderMin = this.sliderDefaultMin;\r\n      this.sliderMax = this.sliderDefaultMax;\r\n    }\r\n  }\r\n\r\n  private _readModelForCheckboxToText(checkboxToTextModel: string): void {\r\n    this._model = checkboxToTextModel;\r\n    if (checkboxToTextModel !== undefined && checkboxToTextModel !== null) {\r\n      this.checkBoxToTextModel = (checkboxToTextModel.indexOf('J') > -1);\r\n    } else {\r\n      this.checkBoxToTextModel = false;\r\n    }\r\n  }\r\n\r\n  private _readModelForCheckboxToBinary(checkboxToBinary: number): void {\r\n    this._model = checkboxToBinary;\r\n    if (checkboxToBinary !== undefined && checkboxToBinary !== null) {\r\n      this.checkBoxToTextModel = (checkboxToBinary >= 1);\r\n    } else {\r\n      this.checkBoxToTextModel = false;\r\n    }\r\n  }\r\n\r\n  private _readModelForDateField(dateFieldModel: string): void {\r\n    this._model = dateFieldModel;\r\n    if (dateFieldModel !== undefined && dateFieldModel !== null) {\r\n      this._model = new Date(dateFieldModel);\r\n    } else {\r\n      this._model = undefined;\r\n    }\r\n  }\r\n\r\n  private _readModelForDateRangeField(dateRangeFieldModel: string): void {\r\n    this._model = dateRangeFieldModel;\r\n    if (dateRangeFieldModel !== undefined && dateRangeFieldModel !== null) {\r\n      let dateCollection = dateRangeFieldModel.split('&');\r\n\r\n      let startString = dateCollection[0].trim().substr(4, dateCollection[0].length - 5);\r\n      let endString = dateCollection[1].trim().substr(4, dateCollection[1].length - 5);\r\n\r\n      let startDateComponents = startString.split('-');\r\n      let endDateComponents = endString.split('-');\r\n\r\n      this.dateRangeStart = new Date(parseInt(startDateComponents[2]), parseInt(startDateComponents[1]) - 1, parseInt(startDateComponents[0]));\r\n      this.dateRangeEnd = new Date(parseInt(endDateComponents[2]), parseInt(endDateComponents[1]) - 1, parseInt(endDateComponents[0]));\r\n    } else {\r\n      this.dateRangeStart = undefined;\r\n      this.dateRangeEnd = undefined;\r\n    }\r\n  }\r\n}\r\n"]}