ax-common-ui-lib 1.0.0-beta.0

package/esm2020/lib/filters/category-filter/category-filter.component.mjs

@@ -0,0 +1,207 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { FilterCategory } from '../../enlighten-lib/filters/filter-category';
+import { Subject } from 'rxjs';
+import { CategoryFilterService } from './category-filter.service';
+import { MAT_SELECT_CONFIG } from '@angular/material/select';
+import * as i0 from "@angular/core";
+import * as i1 from "./category-filter.service";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/common";
+import * as i7 from "../filter-footer/filter-footer.component";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/core";
+function CategoryFilterComponent_mat_option_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 7);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const filter_r2 = ctx.$implicit;
+    i0.ɵɵproperty("value", filter_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", filter_r2.name, " ");
+} }
+export class CategoryFilterComponent {
+    constructor(_categoryFIlterService) {
+        this._categoryFIlterService = _categoryFIlterService;
+        this.resetFilterEvent = new EventEmitter();
+        this.filterValue = new EventEmitter();
+        this.applyFilterEvent = new EventEmitter();
+        this.defaultFilter = [];
+        this.isSelectedAll = false;
+        this.filterList = [];
+        /***
+         * Subject object which helps unsubscribe all the subscribed objects in the component
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this._unsubscribeAll = new Subject();
+    }
+    ngOnInit() {
+        this.defaultFilter = this.category.filters;
+        this._categoryFIlterService.getCategoyFilterList(this.category.id)
+            .then((categoryFilter) => {
+            this.filterList = categoryFilter;
+        });
+        this.resetFilterEvent.subscribe(() => {
+            this.category.filters = this.defaultFilter ? this.defaultFilter : [];
+        });
+        this.addEllipsesToDisplayValue();
+    }
+    /**
+     * ngOnChanges use to change the current page object
+     */
+    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface
+    ngOnChanges(changes) {
+        if (changes['clearFilterCategory'] && changes['clearFilterCategory']?.previousValue !== changes['clearFilterCategory']?.currentValue) {
+            this.isSelectedAll = false;
+        }
+    }
+    /***
+     * On selection of the values of the category filters this method will call.
+     *
+     */
+    filterValueChanged(event) {
+        this.category.isSearchable = true;
+        if (this.filterList.length === this.category.filters.length) {
+            this.isSelectedAll = true;
+        }
+        else {
+            this.isSelectedAll = false;
+        }
+    }
+    /**
+     * Select All Expression Values
+     *
+     * @param selectValue
+     * @param seriesList
+     */
+    selectAll() {
+        this.isSelectedAll = !this.isSelectedAll;
+        if (this.isSelectedAll && this.filterList.length) {
+            this.category.filters = this.filterList;
+            this.category.isSearchable = true;
+        }
+        else {
+            this.category.filters = [];
+            this.category.isSearchable = false;
+        }
+        this.filterValue.emit();
+    }
+    /**
+     *De-Select Expression values
+     *
+     * @param selectedValue
+     */
+    clearAllValue() {
+        this.isSelectedAll = false;
+        this.category.filters = [];
+        this.category.isSearchable = false;
+        this.filterValue.emit();
+        this.applyFilterEvent.emit();
+    }
+    /**
+     *apply filter
+     */
+    applyFilter() {
+        this.applyFilterEvent.emit();
+    }
+    /**
+     * On destroy
+     */
+    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface
+    ngOnDestroy() {
+        // Unsubscribe from all subscriptions
+        this._unsubscribeAll.next();
+        this._unsubscribeAll.complete();
+    }
+    /**
+     * this function use the check and set existing value of catgoery filter
+     *
+     * @param objOne
+     * @param objTwo
+     * @returns
+     */
+    checkSelectedFilter(objOne, objTwo) {
+        if (typeof objOne !== 'undefined' && typeof objTwo !== 'undefined') {
+            return objOne.id === objTwo.id;
+        }
+    }
+    addEllipsesToDisplayValue() {
+        this.toolTipValue = this.category.name;
+        this.displayValue = this.category.name;
+        var words = this.category.name.split(" ");
+        if (words.length > 2) {
+            if (words.length > 3) {
+                this.displayValue = words.slice(0, 3).join(' ') + '...';
+                const valueWidth = document.querySelector('.filter_' + this.category.id + ' .mat-select-value');
+                const valueSpanWidth = valueWidth.querySelector('span');
+                // if(valueWidth.clientWidth > valueSpanWidth.clientWidth){
+                //     if(words.length > 4){
+                //         this.displayValue = words.slice(0, 4).join(' ') + '...';
+                //     }
+                //     else{
+                //         this.displayValue = words.slice(0, 4).join(' ');
+                //     }
+                // }
+            }
+            else {
+                this.displayValue = words.slice(0, 3).join(' ');
+            }
+        }
+    }
+}
+CategoryFilterComponent.ɵfac = function CategoryFilterComponent_Factory(t) { return new (t || CategoryFilterComponent)(i0.ɵɵdirectiveInject(i1.CategoryFilterService)); };
+CategoryFilterComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CategoryFilterComponent, selectors: [["lib-category-filter"]], inputs: { category: "category", resetFilterEvent: "resetFilterEvent", clearFilterCategory: "clearFilterCategory" }, outputs: { filterValue: "filterValue", applyFilterEvent: "applyFilterEvent" }, features: [i0.ɵɵProvidersFeature([
+            {
+                provide: MAT_SELECT_CONFIG,
+                useValue: { overlayPanelClass: 'category-filter-custom-overlay-panel' },
+            },
+        ]), i0.ɵɵNgOnChangesFeature], decls: 7, vars: 10, consts: [[1, "fields", "flex"], ["appearance", "none"], ["panelClass", "category-panel", "multiple", "", 3, "placeholder", "matTooltip", "ngModel", "compareWith", "selectionChange", "ngModelChange"], ["filterMatSelect", ""], ["class", "radio-button my-2 filter-mat-option", 3, "value", 4, "ngFor", "ngForOf"], [3, "isFilterValue", "clearAllValue", "applyFilter", "closeFilter"], [1, "down-arrow", 3, "svgIcon", "click"], [1, "radio-button", "my-2", "filter-mat-option", 3, "value"]], template: function CategoryFilterComponent_Template(rf, ctx) { if (rf & 1) {
+        const _r3 = i0.ɵɵgetCurrentView();
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "mat-form-field", 1);
+        i0.ɵɵelementStart(2, "mat-select", 2, 3);
+        i0.ɵɵlistener("selectionChange", function CategoryFilterComponent_Template_mat_select_selectionChange_2_listener($event) { return ctx.filterValueChanged($event); })("ngModelChange", function CategoryFilterComponent_Template_mat_select_ngModelChange_2_listener($event) { return ctx.category.filters = $event; });
+        i0.ɵɵtemplate(4, CategoryFilterComponent_mat_option_4_Template, 2, 2, "mat-option", 4);
+        i0.ɵɵelementStart(5, "lib-filter-footer", 5);
+        i0.ɵɵlistener("clearAllValue", function CategoryFilterComponent_Template_lib_filter_footer_clearAllValue_5_listener() { return ctx.clearAllValue(); })("applyFilter", function CategoryFilterComponent_Template_lib_filter_footer_applyFilter_5_listener() { return ctx.applyFilter(); })("closeFilter", function CategoryFilterComponent_Template_lib_filter_footer_closeFilter_5_listener() { i0.ɵɵrestoreView(_r3); const _r0 = i0.ɵɵreference(3); return _r0.close(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(6, "mat-icon", 6);
+        i0.ɵɵlistener("click", function CategoryFilterComponent_Template_mat_icon_click_6_listener() { i0.ɵɵrestoreView(_r3); const _r0 = i0.ɵɵreference(3); return _r0.open(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵclassMapInterpolate1("multi-select-dropdown filter_", ctx.category.id.toString(), "");
+        i0.ɵɵproperty("placeholder", ctx.displayValue)("matTooltip", ctx.toolTipValue)("ngModel", ctx.category.filters)("compareWith", ctx.checkSelectedFilter);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngForOf", ctx.filterList);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("isFilterValue", ctx.category.filters);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("svgIcon", "axo_arrow");
+    } }, directives: [i2.MatFormField, i3.MatSelect, i4.MatTooltip, i5.NgControlStatus, i5.NgModel, i6.NgForOf, i7.FilterFooterComponent, i8.MatIcon, i9.MatOption], styles: [""], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CategoryFilterComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-category-filter', encapsulation: ViewEncapsulation.None, providers: [
+                    {
+                        provide: MAT_SELECT_CONFIG,
+                        useValue: { overlayPanelClass: 'category-filter-custom-overlay-panel' },
+                    },
+                ], template: "<div class=\"fields flex\">\n  <mat-form-field appearance=\"none\">\n    <mat-select\n      class=\"multi-select-dropdown filter_{{category.id.toString()}}\"\n      [placeholder]=\"displayValue\"\n      [matTooltip]=\"toolTipValue\"\n      (selectionChange)=\"filterValueChanged($event)\"\n      [(ngModel)]= \"category.filters\"\n      [compareWith]=\"checkSelectedFilter\"\n      panelClass=\"category-panel\"\n      multiple #filterMatSelect>\n      <!-- <div class=\"flex justify-between select-all-option\">\n        <mat-checkbox\n              mat-raised-button\n              class=\"mat-primary fill text-sm mt-2\"\n              [class.mat-checkbox-checked]=\"isSelectedAll\"\n              (click)=\"selectAll()\">\n              Select All\n        </mat-checkbox> -->\n        <!-- <button *ngIf=\"category.filters.length > 0\"\n        <button *ngIf=\"category.filters && category.filters.length > 0\"\n          mat-raised-button\n          class=\"mat-accent fill text-sm clear-all\"\n          (click)=\"clearAllValue()\">\n          Clear All\n        </button> -->\n      <!-- </div> -->\n      <mat-option class=\"radio-button my-2 filter-mat-option\" *ngFor=\"let filter of filterList\" [value]=filter>\n        {{filter.name}}\n      </mat-option>\n      <lib-filter-footer\n          [isFilterValue]=\"category.filters\"\n          (clearAllValue)=\"clearAllValue()\"\n          (applyFilter)=\"applyFilter()\"\n          (closeFilter)=\"filterMatSelect.close()\"\n          >\n        </lib-filter-footer>\n      </mat-select>\n\n    \n  </mat-form-field>\n  <mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"filterMatSelect.open()\"></mat-icon>\n</div>\n", styles: [""] }]
+    }], function () { return [{ type: i1.CategoryFilterService }]; }, { category: [{
+            type: Input
+        }], resetFilterEvent: [{
+            type: Input
+        }], clearFilterCategory: [{
+            type: Input
+        }], filterValue: [{
+            type: Output
+        }], applyFilterEvent: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category-filter.component.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/category-filter/category-filter.component.ts","../../../../../../src/ax-common-ui-lib/src/lib/filters/category-filter/category-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output, SimpleChanges, ViewEncapsulation } from '@angular/core';\nimport { AxFilter } from '../../enlighten-lib/filters/ax-filter';\nimport { FilterCategory } from '../../enlighten-lib/filters/filter-category';\nimport { Subject } from 'rxjs';\nimport { CategoryFilterService } from './category-filter.service';\nimport { AxExpression } from '../../enlighten-lib/ax-expression/ax-expression';\nimport { MAT_SELECT_CONFIG } from '@angular/material/select';\n\n@Component({\n  selector: 'lib-category-filter',\n  templateUrl: './category-filter.component.html',\n  styleUrls: ['./category-filter.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  providers: [\n    {\n      provide: MAT_SELECT_CONFIG,\n      useValue: { overlayPanelClass: 'category-filter-custom-overlay-panel' },\n    },\n  ],\n})\nexport class CategoryFilterComponent implements OnInit {\n  @Input() category: FilterCategory;\n  @Input() resetFilterEvent: EventEmitter<any> = new EventEmitter();\n  @Input() clearFilterCategory: boolean;\n  @Output() filterValue = new EventEmitter<any>();\n  @Output() applyFilterEvent = new EventEmitter<any>();\n\n  defaultFilter: Array<AxFilter> = [];\n\n  isSelectedAll: boolean = false;\n\n  filterList: Array<AxFilter> = [];\n  displayValue: string;\n  toolTipValue:string;\n\n/***\n * Subject object which helps unsubscribe all the subscribed objects in the component\n */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  private _unsubscribeAll: Subject<any> = new Subject<any>();\n\n  constructor(\n    private _categoryFIlterService: CategoryFilterService\n  ) { }\n\n  ngOnInit(): void {\n    this.defaultFilter  = this.category.filters;\n    this._categoryFIlterService.getCategoyFilterList(this.category.id)\n    .then((categoryFilter) => {\n      this.filterList = categoryFilter;\n    });\n    this.resetFilterEvent.subscribe(()=>{\n        this.category.filters = this.defaultFilter?this.defaultFilter:[];\n    })\n    this.addEllipsesToDisplayValue();\n  }\n\n  /**\n   * ngOnChanges use to change the current page object\n   */\n\n  // eslint-disable-next-line @angular-eslint/use-lifecycle-interface\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['clearFilterCategory'] && changes['clearFilterCategory']?.previousValue !== changes['clearFilterCategory']?.currentValue) {\n      this.isSelectedAll = false;\n    }\n  }\n\n  /***\n   * On selection of the values of the category filters this method will call.\n   *\n   */\n   filterValueChanged(event: any): void{\n    this.category.isSearchable = true;\n    if(this.filterList.length === this.category.filters.length){\n      this.isSelectedAll = true;\n    }else{\n      this.isSelectedAll = false;\n    }\n  }\n  /**\n   * Select All Expression Values\n   *\n   * @param selectValue\n   * @param seriesList\n   */\n   selectAll(): void {\n    this.isSelectedAll = !this.isSelectedAll;\n    if(this.isSelectedAll && this.filterList.length){\n      this.category.filters = this.filterList;\n      this.category.isSearchable = true;\n    }else{\n      this.category.filters = [];\n      this.category.isSearchable = false;\n    }\n    this.filterValue.emit();\n  }\n  /**\n   *De-Select Expression values\n   *\n   * @param selectedValue\n   */\n  clearAllValue(): void {\n    this.isSelectedAll = false;\n    this.category.filters = [];\n    this.category.isSearchable = false;\n    this.filterValue.emit();\n    this.applyFilterEvent.emit();\n  }\n\n  /**\n   *apply filter\n   */\n   applyFilter(): void {\n    this.applyFilterEvent.emit();\n  }\n\n\n  /**\n   * On destroy\n   */\n  // eslint-disable-next-line @angular-eslint/use-lifecycle-interface\n  ngOnDestroy(): void {\n    // Unsubscribe from all subscriptions\n    this._unsubscribeAll.next();\n    this._unsubscribeAll.complete();\n  }\n  /**\n   * this function use the check and set existing value of catgoery filter\n   *\n   * @param objOne\n   * @param objTwo\n   * @returns\n   */\n  checkSelectedFilter(objOne: AxFilter, objTwo: AxFilter) {\n    if (typeof objOne !== 'undefined' && typeof objTwo !== 'undefined') {\n      return objOne.id === objTwo.id;\n    }\n  }\n  addEllipsesToDisplayValue(){\n    this.toolTipValue = this.category.name;\n    this.displayValue = this.category.name;\n    var words = this.category.name.split(\" \");\n    \n    if(words.length > 2){\n        if(words.length > 3){\n            this.displayValue = words.slice(0, 3).join(' ') + '...';\n            const valueWidth = document.querySelector('.filter_'+this.category.id+' .mat-select-value') as Element;\n            const valueSpanWidth = valueWidth.querySelector('span') as Element;\n            // if(valueWidth.clientWidth > valueSpanWidth.clientWidth){\n            //     if(words.length > 4){\n            //         this.displayValue = words.slice(0, 4).join(' ') + '...';\n            //     }\n            //     else{\n            //         this.displayValue = words.slice(0, 4).join(' ');\n            //     }\n            // }\n        }\n        else{\n            this.displayValue = words.slice(0, 3).join(' ');\n        }\n    }\n  }\n}\n","<div class=\"fields flex\">\n  <mat-form-field appearance=\"none\">\n    <mat-select\n      class=\"multi-select-dropdown filter_{{category.id.toString()}}\"\n      [placeholder]=\"displayValue\"\n      [matTooltip]=\"toolTipValue\"\n      (selectionChange)=\"filterValueChanged($event)\"\n      [(ngModel)]= \"category.filters\"\n      [compareWith]=\"checkSelectedFilter\"\n      panelClass=\"category-panel\"\n      multiple #filterMatSelect>\n      <!-- <div class=\"flex justify-between select-all-option\">\n        <mat-checkbox\n              mat-raised-button\n              class=\"mat-primary fill text-sm mt-2\"\n              [class.mat-checkbox-checked]=\"isSelectedAll\"\n              (click)=\"selectAll()\">\n              Select All\n        </mat-checkbox> -->\n        <!-- <button *ngIf=\"category.filters.length > 0\"\n        <button *ngIf=\"category.filters && category.filters.length > 0\"\n          mat-raised-button\n          class=\"mat-accent fill text-sm clear-all\"\n          (click)=\"clearAllValue()\">\n          Clear All\n        </button> -->\n      <!-- </div> -->\n      <mat-option class=\"radio-button my-2 filter-mat-option\" *ngFor=\"let filter of filterList\" [value]=filter>\n        {{filter.name}}\n      </mat-option>\n      <lib-filter-footer\n          [isFilterValue]=\"category.filters\"\n          (clearAllValue)=\"clearAllValue()\"\n          (applyFilter)=\"applyFilter()\"\n          (closeFilter)=\"filterMatSelect.close()\"\n          >\n        </lib-filter-footer>\n      </mat-select>\n\n    \n  </mat-form-field>\n  <mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"filterMatSelect.open()\"></mat-icon>\n</div>\n"]}

package/esm2020/lib/filters/category-filter/category-filter.service.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CategoryFilterService {
+    /**
+     * Constructor
+     */
+    constructor(_httpClient) {
+        this._httpClient = _httpClient;
+    }
+    /**
+     * Get Category list by the app-version id
+     */
+    getCategoyFilterList(categoryId) {
+        return new Promise((resolve, reject) => {
+            let params = new HttpParams();
+            params = params.append('categoryId', categoryId);
+            this._httpClient.get('filtercategories/get_filters', { params: params })
+                .subscribe((response) => {
+                resolve(response);
+            }, reject);
+        });
+    }
+}
+CategoryFilterService.ɵfac = function CategoryFilterService_Factory(t) { return new (t || CategoryFilterService)(i0.ɵɵinject(i1.HttpClient)); };
+CategoryFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CategoryFilterService, factory: CategoryFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CategoryFilterService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/filters/category-filter/category.service.mjs

@@ -0,0 +1,45 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CategoryService {
+    constructor(_httpClient) {
+        this._httpClient = _httpClient;
+        this._categoryList = new BehaviorSubject(null);
+        this.updateCategoryListEvent = new EventEmitter();
+    }
+    /**
+     * Getter for entities
+     */
+    get categoryList$() {
+        return this._categoryList.asObservable();
+    }
+    updateCategoryList() {
+        this.updateCategoryListEvent.emit();
+    }
+    /**
+     * @param appVersionId
+     * Get Category list by the app-version id
+     */
+    getCategory(appVersionId) {
+        const params = new HttpParams()
+            .set('AppVersionId', appVersionId);
+        return new Promise((resolve, reject) => {
+            this._httpClient.get(`filtercategories/?${params.toString()}`)
+                .subscribe((response) => {
+                this._categoryList.next(response);
+                resolve(response);
+            }, reject);
+        });
+    }
+}
+CategoryService.ɵfac = function CategoryService_Factory(t) { return new (t || CategoryService)(i0.ɵɵinject(i1.HttpClient)); };
+CategoryService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CategoryService, factory: CategoryService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CategoryService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/filters/choice-list-filter/choice-list-filter.component.mjs

@@ -0,0 +1,178 @@
+import { CommonFilterComponent } from './../common-filter/common-filter.component';
+import { Component, ViewEncapsulation } from '@angular/core';
+import { AxExpTextList } from '../../enlighten-lib/ax-expression/ax-exp-text-list';
+import { AxOperator } from '../../enlighten-lib/filters/ax-operator';
+import { MAT_SELECT_CONFIG } from '@angular/material/select';
+import { CommonFilterService } from '../common-filter/common-filter.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../common-filter/common-filter.service";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/select";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "@angular/forms";
+import * as i6 from "../../axo-search-bar/axo-search-bar.component";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/core";
+import * as i9 from "../filter-footer/filter-footer.component";
+import * as i10 from "@angular/material/icon";
+import * as i11 from "../../axo-utils/search-pipe/choice-search.pipe";
+function ChoiceListFilterComponent_ng_container_6_mat_option_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 10);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const series_r2 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵproperty("matTooltip", series_r2.label ? series_r2.label : series_r2.value)("value", series_r2.value);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", series_r2.label ? series_r2.label : series_r2.value, " ");
+} }
+function ChoiceListFilterComponent_ng_container_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, ChoiceListFilterComponent_ng_container_6_mat_option_1_Template, 2, 3, "mat-option", 9);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const series_r2 = ctx.$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", series_r2.visible);
+} }
+export class ChoiceListFilterComponent extends CommonFilterComponent {
+    constructor(_commonFilterService) {
+        super(_commonFilterService);
+        this._commonFilterService = _commonFilterService;
+        this.seriesList = [];
+    }
+    /**
+     * ngOnChanges use to change the current page object
+     */
+    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes); // called common life cycle hook.S
+    }
+    /**
+     * On init life cycle hook
+     */
+    ngOnInit() {
+        // Called super
+        super.ngOnInit();
+        this.setDisplayValue();
+        this.expression.comparisonOperator = new AxOperator({ text: 'In', value: 'IN' });
+        this.stringOperators = AxOperator.getStringOperator();
+        this.seriesList = this.expression.field.choices;
+    }
+    /**
+     * Set expression value
+     *
+     * @overridden
+     */
+    setExpressionValue() {
+        this.expressionValue = this.expression.value ? this.expression.value : new AxExpTextList();
+    }
+    /**
+     * Get called after view render
+     */
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+    }
+    /**
+     * THis will reset Filter value.
+     */
+    resetFilter() {
+        this.expressionValue = new AxExpTextList(this.defaultValue);
+        this.expression.value = this.expressionValue;
+    }
+    /**
+     * This function clear the filter value.
+     */
+    clearValue() {
+        this.expressionValue = new AxExpTextList();
+        this.expression.value = this.expressionValue;
+    }
+    /**
+     * Set Default Value
+     *
+     * @overridden
+     */
+    setDefaultValue() {
+        this.defaultValue = new AxExpTextList(this.expressionValue);
+    }
+    /**
+     * Apply parent value parent value change
+     */
+    applyParentFilter() {
+        this.expressionValue.value = [];
+        this.pageIndex = 0;
+        this.seriesList = [];
+        this.getSeriesList();
+    }
+    /**
+     * Clear Values
+     *
+     */
+    clearAllValue() {
+        this.expressionValue.value = [];
+        this.filterValueChanged();
+        this.applyFilterEvent.emit();
+    }
+    /**
+     *  Search Text changed.
+     *
+     * @overridden
+     */
+    searchTextChanged(searchText) {
+        this.searchText = searchText;
+    }
+    setDisplayValue() {
+        this.addEllipsesToDisplayValue(this.expression.field.label);
+    }
+}
+ChoiceListFilterComponent.ɵfac = function ChoiceListFilterComponent_Factory(t) { return new (t || ChoiceListFilterComponent)(i0.ɵɵdirectiveInject(i1.CommonFilterService)); };
+ChoiceListFilterComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ChoiceListFilterComponent, selectors: [["choice-list-filter"]], features: [i0.ɵɵProvidersFeature([
+            {
+                provide: MAT_SELECT_CONFIG,
+                useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },
+            },
+        ]), i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], decls: 11, vars: 10, consts: [[1, "fields", "flex"], ["appearance", "none"], ["panelClass", "multi-select-panel", "multiple", "", 1, "multi-select-dropdown", 3, "placeholder", "matTooltip", "ngModel", "selectionChange", "ngModelChange"], ["choiceList", ""], [3, "searchText", "searchTextChanged"], [4, "ngFor", "ngForOf"], [1, "hidden"], [3, "isFilterValue", "clearAllValue", "applyFilter", "closeFilter"], [1, "down-arrow", 3, "svgIcon", "click"], ["class", "radio-button my-2", 3, "matTooltip", "value", 4, "ngIf"], [1, "radio-button", "my-2", 3, "matTooltip", "value"]], template: function ChoiceListFilterComponent_Template(rf, ctx) { if (rf & 1) {
+        const _r5 = i0.ɵɵgetCurrentView();
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "mat-form-field", 1);
+        i0.ɵɵelementStart(2, "mat-select", 2, 3);
+        i0.ɵɵlistener("selectionChange", function ChoiceListFilterComponent_Template_mat_select_selectionChange_2_listener() { return ctx.filterValueChanged(); })("ngModelChange", function ChoiceListFilterComponent_Template_mat_select_ngModelChange_2_listener($event) { return ctx.expressionValue.value = $event; });
+        i0.ɵɵelementStart(4, "axo-search-bar", 4);
+        i0.ɵɵlistener("searchTextChanged", function ChoiceListFilterComponent_Template_axo_search_bar_searchTextChanged_4_listener($event) { return ctx.searchTextChanged($event); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(5, "div");
+        i0.ɵɵtemplate(6, ChoiceListFilterComponent_ng_container_6_Template, 2, 1, "ng-container", 5);
+        i0.ɵɵpipe(7, "choiceSearch");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(8, "mat-option", 6);
+        i0.ɵɵelementStart(9, "lib-filter-footer", 7);
+        i0.ɵɵlistener("clearAllValue", function ChoiceListFilterComponent_Template_lib_filter_footer_clearAllValue_9_listener() { return ctx.clearAllValue(); })("applyFilter", function ChoiceListFilterComponent_Template_lib_filter_footer_applyFilter_9_listener() { return ctx.applyFilter(); })("closeFilter", function ChoiceListFilterComponent_Template_lib_filter_footer_closeFilter_9_listener() { i0.ɵɵrestoreView(_r5); const _r0 = i0.ɵɵreference(3); return _r0.close(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(10, "mat-icon", 8);
+        i0.ɵɵlistener("click", function ChoiceListFilterComponent_Template_mat_icon_click_10_listener() { i0.ɵɵrestoreView(_r5); const _r0 = i0.ɵɵreference(3); return _r0.open(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("placeholder", ctx.displayValue)("matTooltip", ctx.toolTipValue)("ngModel", ctx.expressionValue.value);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("searchText", ctx.searchText);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind2(7, 7, ctx.seriesList, ctx.searchText));
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("isFilterValue", ctx.seriesList && ctx.seriesList.length);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("svgIcon", "axo_arrow");
+    } }, directives: [i2.MatFormField, i3.MatSelect, i4.MatTooltip, i5.NgControlStatus, i5.NgModel, i6.AxoSearchBarComponent, i7.NgForOf, i8.MatOption, i9.FilterFooterComponent, i10.MatIcon, i7.NgIf], pipes: [i11.ChoiceSearchPipe], styles: [""], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ChoiceListFilterComponent, [{
+        type: Component,
+        args: [{ selector: 'choice-list-filter', encapsulation: ViewEncapsulation.None, providers: [
+                    {
+                        provide: MAT_SELECT_CONFIG,
+                        useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },
+                    },
+                ], template: "<div class=\"fields flex\">\n    <mat-form-field appearance=\"none\">\n        <mat-select class=\"multi-select-dropdown\" [placeholder]=\"displayValue\"\n            [matTooltip]=\"toolTipValue\" (selectionChange)=\"filterValueChanged()\"\n            [(ngModel)]=\"expressionValue.value\" panelClass=\"multi-select-panel\" multiple #choiceList>\n            <!-- Search Box -->\n            <axo-search-bar [searchText]=\"searchText\" (searchTextChanged)=\"searchTextChanged($event)\"></axo-search-bar>\n            <div >\n                <ng-container *ngFor=\"let series of seriesList | choiceSearch: searchText\">\n                    <mat-option *ngIf=\"series.visible\" class=\"radio-button my-2\" [matTooltip]=\"series.label?series.label:series.value\" [value]=\"series.value\">\n                        {{series.label?series.label:series.value}}\n                    </mat-option>\n                </ng-container>\n            </div>\n\n            <!-- this option is for opening the dropdown even if series is empty -->\n            <mat-option class=\"hidden\"></mat-option>\n\n            <lib-filter-footer [isFilterValue]=\"(seriesList && seriesList.length)\" (clearAllValue)=\"clearAllValue()\"\n                (applyFilter)=\"applyFilter()\" (closeFilter)=\"choiceList.close()\">\n            </lib-filter-footer>\n        </mat-select>\n        \n    </mat-form-field>\n    <mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"choiceList.open()\"></mat-icon>\n</div>\n", styles: [""] }]
+    }], function () { return [{ type: i1.CommonFilterService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"choice-list-filter.component.js","sourceRoot":"","sources":["../../../../../../src/ax-common-ui-lib/src/lib/filters/choice-list-filter/choice-list-filter.component.ts","../../../../../../src/ax-common-ui-lib/src/lib/filters/choice-list-filter/choice-list-filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChoiceListOption } from './../../forms/page/widgets/widget-value/choice-list-options';\nimport { CommonFilterComponent } from './../common-filter/common-filter.component';\nimport { Component, OnInit, SimpleChanges, ViewEncapsulation, OnChanges, AfterViewInit } from '@angular/core';\nimport { AxExpTextList } from '../../enlighten-lib/ax-expression/ax-exp-text-list';\nimport { AxOperator } from '../../enlighten-lib/filters/ax-operator';\nimport { MAT_SELECT_CONFIG } from '@angular/material/select';\nimport { CommonFilterService } from '../common-filter/common-filter.service';\n\n\n@Component({\n    selector: 'choice-list-filter',\n    templateUrl: './choice-list-filter.component.html',\n    styleUrls: ['./choice-list-filter.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    providers: [\n        {\n            provide: MAT_SELECT_CONFIG,\n            useValue: { overlayPanelClass: 'custom-multi-select-overlay-panel' },\n        },\n    ],\n})\nexport class ChoiceListFilterComponent extends CommonFilterComponent implements OnInit, OnChanges, AfterViewInit {\n    //<----------< Inputs >---------------------------->\n\n    //<-----------<Outputs >--------------------------->\n\n    //<-------------(Enums )--------------------------->\n\n    //<-------------(Component Variables )------------->\n    expressionValue: AxExpTextList;\n    stringOperators: Array<AxOperator>;\n    seriesList: Array<ChoiceListOption> = [];\n    constructor(public _commonFilterService: CommonFilterService) {\n        super(_commonFilterService);\n    }\n\n    /**\n     * ngOnChanges use to change the current page object\n     */\n    // eslint-disable-next-line @angular-eslint/use-lifecycle-interface\n    ngOnChanges(changes: SimpleChanges): void {\n        super.ngOnChanges(changes); // called common life cycle hook.S\n    }\n\n    /**\n     * On init life cycle hook\n     */\n    ngOnInit(): void {\n        // Called super\n        super.ngOnInit();\n        this.setDisplayValue();\n        this.expression.comparisonOperator = new AxOperator({ text: 'In', value: 'IN' });\n        this.stringOperators = AxOperator.getStringOperator();\n        this.seriesList = this.expression.field.choices;\n    }\n\n    /**\n     * Set expression value\n     *\n     * @overridden\n     */\n     setExpressionValue(): void {\n        this.expressionValue = this.expression.value ? this.expression.value as AxExpTextList : new AxExpTextList();\n    }\n\n    /**\n     * Get called after view render\n     */\n    ngAfterViewInit(): void {\n        super.ngAfterViewInit();\n    }\n\n    /**\n     * THis will reset Filter value.\n     */\n    resetFilter(): void {\n        this.expressionValue = new AxExpTextList(this.defaultValue);\n        this.expression.value = this.expressionValue;\n    }\n\n    /**\n     * This function clear the filter value.\n     */\n    clearValue(): void {\n        this.expressionValue = new AxExpTextList();\n        this.expression.value = this.expressionValue;\n    }\n    /**\n     * Set Default Value\n     *\n     * @overridden\n     */\n    setDefaultValue(): void {\n        this.defaultValue =  new AxExpTextList(this.expressionValue);\n    }\n\n    /**\n     * Apply parent value parent value change\n     */\n    applyParentFilter(): void {\n        this.expressionValue.value = [];\n        this.pageIndex = 0;\n        this.seriesList = [];\n        this.getSeriesList();\n    }\n    /**\n     * Clear Values\n     *\n     */\n    clearAllValue(): void {\n        this.expressionValue.value = [];\n        this.filterValueChanged();\n        this.applyFilterEvent.emit();\n    }\n\n    /**\n     *  Search Text changed.\n     *\n     * @overridden\n     */\n     searchTextChanged(searchText: string): void{\n        this.searchText = searchText;\n     }\n\n     setDisplayValue(): void {\n         this.addEllipsesToDisplayValue(this.expression.field.label);\n     }\n}\n","<div class=\"fields flex\">\n    <mat-form-field appearance=\"none\">\n        <mat-select class=\"multi-select-dropdown\" [placeholder]=\"displayValue\"\n            [matTooltip]=\"toolTipValue\" (selectionChange)=\"filterValueChanged()\"\n            [(ngModel)]=\"expressionValue.value\" panelClass=\"multi-select-panel\" multiple #choiceList>\n            <!-- Search Box -->\n            <axo-search-bar [searchText]=\"searchText\" (searchTextChanged)=\"searchTextChanged($event)\"></axo-search-bar>\n            <div >\n                <ng-container *ngFor=\"let series of seriesList | choiceSearch: searchText\">\n                    <mat-option *ngIf=\"series.visible\" class=\"radio-button my-2\" [matTooltip]=\"series.label?series.label:series.value\" [value]=\"series.value\">\n                        {{series.label?series.label:series.value}}\n                    </mat-option>\n                </ng-container>\n            </div>\n\n            <!-- this option is for opening the dropdown even if series is empty -->\n            <mat-option class=\"hidden\"></mat-option>\n\n            <lib-filter-footer [isFilterValue]=\"(seriesList && seriesList.length)\" (clearAllValue)=\"clearAllValue()\"\n                (applyFilter)=\"applyFilter()\" (closeFilter)=\"choiceList.close()\">\n            </lib-filter-footer>\n        </mat-select>\n        \n    </mat-form-field>\n    <mat-icon class=\"down-arrow\" [svgIcon]=\"'axo_arrow'\" (click)=\"choiceList.open()\"></mat-icon>\n</div>\n"]}

package/esm2020/lib/filters/choice-list-filter/choice-list-filter.service.mjs

@@ -0,0 +1,53 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FilterProperty } from '../../enlighten-lib/property/filter-property';
+import * as i0 from "@angular/core";
+export class ChoiceListFilterService {
+    /**
+     * Constructor
+     */
+    constructor() {
+        this.refreshFilterPropertyEvent = new EventEmitter();
+        this.parentEventEmitterRef = new EventEmitter();
+        this.refreshChildFilterEventEmitterRef = new EventEmitter();
+        this._parentFilterList = new BehaviorSubject(null);
+    }
+    /**
+     * Getter for entities
+     */
+    get parentFilterList$() {
+        return this._parentFilterList.asObservable();
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshChildFilter(parentFilterKey, parentFilter) {
+        this.refreshChildFilterEventEmitterRef.emit({ parentKey: parentFilterKey, parentValue: parentFilter });
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshFilterProperty(filter) {
+        const filterProperty = new FilterProperty();
+        filterProperty.filter = filter;
+        this.refreshFilterPropertyEvent.emit(filterProperty);
+    }
+    /**
+     * when filter click then open filter properties.
+     */
+    refreshFilterListProperty(filters) {
+        this._parentFilterList.next(filters);
+    }
+    /**
+     * when parent filter add to child filter then call
+     */
+    refreshParentEventEmitter(guid) {
+        this.parentEventEmitterRef.emit(guid);
+    }
+}
+ChoiceListFilterService.ɵfac = function ChoiceListFilterService_Factory(t) { return new (t || ChoiceListFilterService)(); };
+ChoiceListFilterService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ChoiceListFilterService, factory: ChoiceListFilterService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ChoiceListFilterService, [{
+        type: Injectable
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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