@pepperi-addons/ngx-lib 0.2.55 → 0.2.58-beta.1

package/esm2015/smart-filters/filter-builder/filter-builder-item/filter-builder-item.component.js

@@ -0,0 +1,106 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+export class FilterBuilderItemComponent {
+    constructor(_fb) {
+        this._fb = _fb;
+        this._fields = [];
+        this._options = [];
+        this._selectedField = null;
+        this.filterChange = new EventEmitter();
+        this.remove = new EventEmitter();
+        this.test = {};
+        this.fieldWidth = 26;
+        this.filterWidth = 67.5;
+        this.binWidth = 6.5;
+        this.setupForm();
+    }
+    set fields(list) {
+        if ((list === null || list === void 0 ? void 0 : list.length) > 0) {
+            this._fields = list;
+            this._options = list.map(field => {
+                return {
+                    key: field.id,
+                    value: field.name
+                };
+            });
+        }
+    }
+    ;
+    set selected(value) {
+        if (value) {
+            this._selectedField = value;
+        }
+    }
+    set filter(value) {
+        if (value) {
+            this._filter = value;
+        }
+    }
+    ;
+    set parentForm(value) {
+        if (value) {
+            this._parentForm = value;
+            this.addToParentForm();
+        }
+    }
+    ;
+    ngOnInit() {
+    }
+    setupForm() {
+        this._form = this._fb.group({
+            fieldId: this._fb.control(null),
+            fieldType: this._fb.control(null),
+            operator: this._fb.control(null),
+            operatorUnit: this._fb.control(null),
+            values: this._fb.group({
+                first: this._fb.control(null),
+                second: this._fb.control(null)
+            }),
+        });
+    }
+    addToParentForm() {
+        this._parentForm.setControl(this.formKey, this._form);
+    }
+    onFieldChanged(key) {
+        let item = this._fields.find(field => field.id === key);
+        this.setupForm();
+        this.addToParentForm();
+        /**
+         * hack due to angular's change detection bug -
+         * ERROR Error: There is no FormControl instance attached to form control element with name: [formControlName]
+         */
+        this._selectedField = null;
+        setTimeout(() => {
+            this._selectedField = item ? item : null;
+        }, 0);
+        this._filter = null;
+    }
+    onFilterChanged() {
+        if (this._form.valid) {
+            this.filterChange.emit();
+        }
+    }
+    onDeleteItemClicked() {
+        this.remove.emit();
+    }
+}
+FilterBuilderItemComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pep-filter-builder-item',
+                template: "<div class=\"filter-item-container\" fxLayout=\"column\" fxLayoutGap=\".5rem\">\n    <div fxLayout=\"row\" fxLayoutGap=\".5rem\">\n        <pep-select fxFlex=\"25%\" [value]=\"_selectedField?.id\" xAlignment=\"left\" [options]=\"_options\"\n            [renderTitle]=\"false\" (valueChange)=\"onFieldChanged($event)\"></pep-select>\n        <ng-container *ngIf=\"_selectedField?.componentType\">\n            <ng-container [ngSwitch]=\"_selectedField.componentType\">\n                <ng-container *ngSwitchCase=\"'text'\">\n                    <pep-text-filter fxFlex=\"auto\" [showActionButtons]=\"false\" [field]=\"_selectedField\"\n                        [filter]=\"_filter\" [parentForm]=\"_form\" [emitOnChange]=\"true\" [inline]=\"true\"\n                        [renderTitle]=\"false\" (filterChange)=\"onFilterChanged()\">\n                    </pep-text-filter>\n                </ng-container>\n                <ng-container *ngSwitchCase=\"'boolean'\">\n                    <pep-boolean-filter fxFlex=\"auto\" [showActionButtons]=\"false\" [field]=\"_selectedField\"\n                        [filter]=\"_filter\" [parentForm]=\"_form\" [emitOnChange]=\"true\" [inline]=\"true\"\n                        [renderTitle]=\"false\" (filterChange)=\"onFilterChanged()\">\n                    </pep-boolean-filter>\n                </ng-container>\n                <ng-container *ngSwitchCase=\"'date'\">\n                    <pep-date-filter fxFlex=\"auto\" [showActionButtons]=\"false\" [field]=\"_selectedField\"\n                        [filter]=\"_filter\" [parentForm]=\"_form\" [emitOnChange]=\"true\" [inline]=\"true\"\n                        [renderTitle]=\"false\" (filterChange)=\"onFilterChanged()\">\n                    </pep-date-filter>\n                </ng-container>\n                <ng-container *ngSwitchCase=\"'multi-select'\">\n                    <pep-multi-select-filter fxFlex=\"auto\" [showActionButtons]=\"false\" [field]=\"_selectedField\"\n                        [filter]=\"_filter\" [parentForm]=\"_form\" [emitOnChange]=\"true\" [inline]=\"true\"\n                        [renderTitle]=\"false\" (filterChange)=\"onFilterChanged()\">\n                    </pep-multi-select-filter>\n                </ng-container>\n                <ng-container *ngSwitchCase=\"'number'\">\n                    <pep-number-filter fxFlex=\"auto\" [showActionButtons]=\"false\" [field]=\"_selectedField\"\n                        [filter]=\"_filter\" [parentForm]=\"_form\" [emitOnChange]=\"true\" [inline]=\"true\"\n                        [renderTitle]=\"false\" (filterChange)=\"onFilterChanged()\">\n                    </pep-number-filter>\n                </ng-container>\n            </ng-container>\n        </ng-container>\n        <!-- <ng-container *ngIf=\"(_parentForm | filterItemCounter) > 1\"> -->\n        <pep-button styleType=\"weak\" styleStateType=\"system_bin\" sizeType=\"md\" classNames=\"\" [disabled]=\"false\"\n            iconName=\"system_bin\" iconPosition=\"end\" [visible]=\"true\" (buttonClick)=\"onDeleteItemClicked()\">\n        </pep-button>\n        <!-- </ng-container>         -->\n    </div>\n</div>",
+                styles: [""]
+            },] }
+];
+FilterBuilderItemComponent.ctorParameters = () => [
+    { type: FormBuilder }
+];
+FilterBuilderItemComponent.propDecorators = {
+    formKey: [{ type: Input }],
+    fields: [{ type: Input }],
+    selected: [{ type: Input }],
+    filter: [{ type: Input }],
+    parentForm: [{ type: Input }],
+    filterChange: [{ type: Output }],
+    remove: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-builder-item.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/smart-filters/filter-builder/filter-builder-item/filter-builder-item.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAA+B,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAQ,WAAW,EAAyB,MAAM,gBAAgB,CAAC;AAY1E,MAAM,OAAO,0BAA0B;IAoDnC,YAAoB,GAAgB;QAAhB,QAAG,GAAH,GAAG,CAAa;QAlDpC,YAAO,GAAe,EAAE,CAAC;QACzB,aAAQ,GAAiB,EAAE,CAAC;QAa5B,mBAAc,GAA4B,IAAI,CAAC;QAwB/C,iBAAY,GAAG,IAAI,YAAY,EAAE,CAAC;QAElC,WAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAG5B,SAAI,GAAQ,EAAE,CAAC;QAGf,eAAU,GAAG,EAAE,CAAC;QAChB,gBAAW,GAAG,IAAI,CAAC;QACnB,aAAQ,GAAG,GAAG,CAAC;QAGX,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IAlDD,IACI,MAAM,CAAC,IAAiC;QACxC,IAAI,CAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,IAAG,CAAC,EAAE;YAClB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBAC7B,OAAO;oBACH,GAAG,EAAE,KAAK,CAAC,EAAE;oBACb,KAAK,EAAE,KAAK,CAAC,IAAI;iBACpB,CAAA;YACL,CAAC,CAAC,CAAA;SACL;IACL,CAAC;IAAA,CAAC;IAEF,IACI,QAAQ,CAAC,KAAU;QACnB,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;SAC/B;IACL,CAAC;IAED,IACI,MAAM,CAAC,KAA0B;QACjC,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;SACxB;IACL,CAAC;IAAA,CAAC;IAEF,IACI,UAAU,CAAC,KAAgB;QAC3B,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;YACzB,IAAI,CAAC,eAAe,EAAE,CAAC;SAC1B;IACL,CAAC;IAAA,CAAC;IAmBF,QAAQ;IAER,CAAC;IAED,SAAS;QACL,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;YACxB,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;YAC/B,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;YACjC,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;YAChC,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;YACpC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;gBACnB,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;gBAC7B,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC;aACjC,CAAC;SACL,CAAC,CAAC;IACP,CAAC;IAED,eAAe;QACX,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1D,CAAC;IAED,cAAc,CAAC,GAAG;QACd,IAAI,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC;QAExD,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,eAAe,EAAE,CAAC;QAEvB;;;WAGG;QACH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,UAAU,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAC7C,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACxB,CAAC;IAED,eAAe;QACX,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;YAClB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAED,mBAAmB;QACf,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;;;YA5GJ,SAAS,SAAC;gBACP,QAAQ,EAAE,yBAAyB;gBACnC,smGAAmD;;aAEtD;;;YAXc,WAAW;;;sBAarB,KAAK;qBAGL,KAAK;uBAaL,KAAK;qBAOL,KAAK;yBAOL,KAAK;2BAQL,MAAM;qBAEN,MAAM","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output, ViewChild, ViewContainerRef } from '@angular/core';\nimport { Form, FormBuilder, FormGroup, Validators } from '@angular/forms';\nimport { FilterBuilderService } from '../filter-builder.service';\nimport { PepSmartFilterType } from '../../common/model/type';\nimport { PepSmartFilterBaseField, IPepSmartFilterField } from '../../common/model/field';\nimport { IPepSmartFilterData } from '../../common/model/filter';\nimport { IPepOption } from '@pepperi-addons/ngx-lib';\n\n@Component({\n    selector: 'pep-filter-builder-item',\n    templateUrl: './filter-builder-item.component.html',\n    styleUrls: ['./filter-builder-item.component.scss'],\n})\nexport class FilterBuilderItemComponent {\n    @Input() formKey: string;\n    _fields: Array<any> = [];\n    _options: IPepOption[] = [];\n    @Input()\n    set fields(list: Array<IPepSmartFilterField>) {\n        if (list?.length > 0) {\n            this._fields = list;\n            this._options = list.map(field => {\n                return {\n                    key: field.id,\n                    value: field.name\n                }\n            })\n        }\n    };\n    _selectedField: PepSmartFilterBaseField = null;\n    @Input()\n    set selected(value: any) {\n        if (value) {\n            this._selectedField = value;\n        }\n    }\n    _filter: IPepSmartFilterData;\n    @Input()\n    set filter(value: IPepSmartFilterData) {\n        if (value) {\n            this._filter = value;\n        }\n    };\n    _parentForm: FormGroup;\n    @Input()\n    set parentForm(value: FormGroup) {\n        if (value) {\n            this._parentForm = value;\n            this.addToParentForm();\n        }\n    };\n\n    @Output()\n    filterChange = new EventEmitter();\n    @Output()\n    remove = new EventEmitter();\n\n\n    test: any = {};\n\n    _form: FormGroup;\n    fieldWidth = 26;\n    filterWidth = 67.5;\n    binWidth = 6.5;\n\n    constructor(private _fb: FormBuilder) {\n        this.setupForm();\n    }\n\n    ngOnInit() {\n\n    }\n\n    setupForm() {\n        this._form = this._fb.group({\n            fieldId: this._fb.control(null),\n            fieldType: this._fb.control(null),\n            operator: this._fb.control(null),\n            operatorUnit: this._fb.control(null),\n            values: this._fb.group({\n                first: this._fb.control(null),\n                second: this._fb.control(null)\n            }),\n        });\n    }\n\n    addToParentForm() {\n        this._parentForm.setControl(this.formKey, this._form);\n    }\n\n    onFieldChanged(key) {\n        let item = this._fields.find(field => field.id === key);\n\n        this.setupForm();\n        this.addToParentForm();\n\n        /**\n         * hack due to angular's change detection bug -\n         * ERROR Error: There is no FormControl instance attached to form control element with name: [formControlName]\n         */\n        this._selectedField = null;\n        setTimeout(() => {\n            this._selectedField = item ? item : null;\n        }, 0);\n\n        this._filter = null;\n    }\n\n    onFilterChanged() {\n        if (this._form.valid) {\n            this.filterChange.emit();\n        }\n    }\n\n    onDeleteItemClicked() {\n        this.remove.emit();\n    }\n\n\n\n}\n"]}

package/esm2015/smart-filters/filter-builder/filter-builder-section/filter-builder-section.component.js

@@ -0,0 +1,50 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewContainerRef } from '@angular/core';
+import { FilterBuilderService } from '../filter-builder.service';
+import { PepOperatorTypes } from '../common/model/type';
+import { PepTypeConvertorService } from '../common/services/type-convertor.service';
+export class FilterBuilderSectionComponent {
+    constructor(filterBuilderService, typeConvertorService) {
+        this.filterBuilderService = filterBuilderService;
+        this.typeConvertorService = typeConvertorService;
+        this.remove = new EventEmitter();
+        this.operatorChange = new EventEmitter();
+    }
+    ngOnInit() {
+    }
+    get f() {
+        return this.form.controls;
+    }
+    onOperatorChanged(value) {
+        this.f.operator.setValue(value);
+        this.operatorChange.emit();
+    }
+    onAddRuleClicked() {
+        this.filterBuilderService.createItem(null, this.sectionContainer, this.form);
+    }
+    onAddRuleSetClicked() {
+        const result = this.filterBuilderService.createSection(PepOperatorTypes.And, this.sectionContainer, this.form, this.depth + 1);
+        this.filterBuilderService.createItem(null, result.containerRef, result.parentForm);
+    }
+    onDeleteSectionClicked() {
+        this.remove.emit();
+    }
+}
+FilterBuilderSectionComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pep-filter-builder-section',
+                template: "<div fxLayout=\"row\" fxLayoutGap=\".5rem\">\n    <div class=\"filter-section-container\" fxLayout=\"row\" fxLayoutAlign=\"flex-start start\" fxLayoutGap=\".5rem\">\n        <pep-select fxFlex=\"11\" [value]=\"f.operator.value\" xAlignment=\"left\" [options]=\"typeConvertorService.operators\"\n            [renderTitle]=\"false\" [emptyOption]=false (valueChange)=\"onOperatorChanged($event)\">\n        </pep-select>\n        <div fxFlex=\"89\" class=\"filter-section-wrapper\" fxLayout=\"column\" fxLayoutGap=\".5rem\">\n            <ng-container #sectionContainer></ng-container>\n            <div fxLayout=\"row\" fxLayoutGap=\".5rem\">\n                <pep-button value=\"Add Filter\" styleType=\"weak\" styleStateType=\"system\" sizeType=\"sm\" classNames=\"\"\n                    [disabled]=\"false\" iconName=\"number_plus\" iconPosition=\"end\" [visible]=\"true\"\n                    (buttonClick)=\"onAddRuleClicked()\"></pep-button>\n                <ng-container *ngIf=\"depth < filterBuilderService.maxDepth-1\">\n                    <pep-button value=\"Add Filter Group\" styleType=\"weak\" styleStateType=\"system\" sizeType=\"sm\"\n                        classNames=\"\" [disabled]=\"false\" iconName=\"number_plus\" iconPosition=\"end\" [visible]=\"true\"\n                        (buttonClick)=\"onAddRuleSetClicked()\"></pep-button>\n                </ng-container>\n            </div>\n        </div>\n    </div>\n    <pep-button *ngIf=\"depth > 0\" styleType=\"weak\" styleStateType=\"system_bin\" sizeType=\"md\" classNames=\"\"\n        [disabled]=\"false\" iconName=\"system_bin\" iconPosition=\"end\" [visible]=\"true\"\n        (buttonClick)=\"onDeleteSectionClicked()\">\n    </pep-button>\n</div>",
+                styles: [".filter-section-wrapper{width:100%}.filter-section-container{border-radius:.25rem;border-radius:var(--pep-border-radius-md,.25rem);padding:.5rem;width:100%}"]
+            },] }
+];
+FilterBuilderSectionComponent.ctorParameters = () => [
+    { type: FilterBuilderService },
+    { type: PepTypeConvertorService }
+];
+FilterBuilderSectionComponent.propDecorators = {
+    form: [{ type: Input }],
+    depth: [{ type: Input }],
+    remove: [{ type: Output }],
+    operatorChange: [{ type: Output }],
+    sectionContainer: [{ type: ViewChild, args: ['sectionContainer', { read: ViewContainerRef, static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/smart-filters/filter-builder/filter-builder.component.js

@@ -0,0 +1,65 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewContainerRef } from '@angular/core';
+import { FilterBuilderService } from './filter-builder.service';
+import { FormBuilder } from '@angular/forms';
+export class FilterBuilderComponent {
+    constructor(_fb, _filterBuilderService) {
+        this._fb = _fb;
+        this._filterBuilderService = _filterBuilderService;
+        this.json = null;
+        this.fields = new Array();
+        this.filters = new EventEmitter();
+        this.formValidationChange = new EventEmitter();
+        this._isFormValid = true;
+        this.setupForm();
+        this._formSubscription$ = this.form.valueChanges.subscribe((val) => {
+            if (this.form.valid !== this._isFormValid) {
+                this._isFormValid = this.form.valid;
+                this.formValidationChange.emit(this._isFormValid);
+            }
+        });
+        this._outputJsonSubscription$ = this._filterBuilderService.triggerOutputJson.subscribe((outputJson) => {
+            this.filters.emit(outputJson);
+        });
+    }
+    setupForm() {
+        this.form = this._fb.group({});
+    }
+    ngOnInit() {
+        this._filterBuilderService.createFilterTree(this.json, this.fields, this.form, this.filterRoot);
+    }
+    /*
+    ngAfterViewInit() {
+        //this._filterBuilderService.createFilterTree(this.json, this.fields, this.form, this.filterRoot);
+    }
+
+    ngAfterViewChecked() {
+        //this._changeDetectionRef.detectChanges();
+    } */
+    ngOnDestroy() {
+        if (this._formSubscription$) {
+            this._formSubscription$.unsubscribe();
+        }
+        if (this._outputJsonSubscription$) {
+            this._outputJsonSubscription$.unsubscribe();
+        }
+    }
+}
+FilterBuilderComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pep-filter-builder',
+                template: "<!-- <div class=\"filter-builder-container\"> -->\n<ng-container #filterRoot></ng-container>\n<!-- </div> -->",
+                styles: [""]
+            },] }
+];
+FilterBuilderComponent.ctorParameters = () => [
+    { type: FormBuilder },
+    { type: FilterBuilderService }
+];
+FilterBuilderComponent.propDecorators = {
+    json: [{ type: Input }],
+    fields: [{ type: Input }],
+    filters: [{ type: Output }],
+    formValidationChange: [{ type: Output }],
+    filterRoot: [{ type: ViewChild, args: ['filterRoot', { read: ViewContainerRef, static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/smart-filters/filter-builder/filter-builder.service.js

@@ -0,0 +1,261 @@
+import { Injectable, ComponentFactoryResolver } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { PepSmartFilterOperators } from '../common/model/operator';
+import { createSmartFilter, createSmartFilterField } from '../common/model/creator';
+//import { getSmartBuilderType } from './common/model/type';
+//import { convertToSmartFilterFields } from './common/model/field';
+import { getSmartBuilderOperator } from './common/model/operator';
+import { FilterBuilderSectionComponent } from './filter-builder-section/filter-builder-section.component';
+import { FilterBuilderItemComponent } from './filter-builder-item/filter-builder-item.component';
+import { PepFilterBuilderTypeMap } from './common/model/type-map';
+import { getSmartBuilderOperationUnit } from './common/model/operator-unit';
+//import { PepFilterBuilderOperatorUnitMap } from './common/model/operator-unit-map';
+import { PepOutputFilterService } from './common/services/output-filter.service';
+import { PepOperatorTypes } from './common/model/type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./common/services/output-filter.service";
+export class FilterBuilderService {
+    constructor(_fb, _resolver, _outputJsonService) {
+        this._fb = _fb;
+        this._resolver = _resolver;
+        this._outputJsonService = _outputJsonService;
+        this.MAX_STRUCTURE_DEPTH = 3;
+        this._outputJsonSubject = new BehaviorSubject(null);
+        this.triggerOutputJson = this._outputJsonSubject.asObservable();
+    }
+    get maxDepth() {
+        return this.MAX_STRUCTURE_DEPTH;
+    }
+    /**
+     * creates a dynamic filter structure
+     * might has a different structure than the input's due to merge of parent-child elements
+     * @param json legacy JSON
+     * @param fields an array of legacy fields
+     * @param containerRef reference to root element
+     */
+    createFilterTree(json, fields, form, containerRef) {
+        this._form = form;
+        this._smartFilterFields = this.convertToSmartFilterFields(fields);
+        const result = this.createSection((json === null || json === void 0 ? void 0 : json.Operation) ? json.Operation : PepOperatorTypes.And, containerRef, this._form, 0);
+        if (json) {
+            this.flatten(json, json.LeftNode, result.containerRef, result.parentForm, 1);
+            this.flatten(json, json.RightNode, result.containerRef, result.parentForm, 1);
+        }
+    }
+    /**
+    * checks if the object contains property
+    * @param obj object
+    * @param prop property name
+    * @returns true if contains, false otherwise
+    */
+    hasProperty(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+    /**
+     * a recursive function dynamically builds filters structure
+     * @param parent legacy complex object
+     * @param current child legacy object (either another complex or expression type)
+     * @param containerRef parent element
+     * @param parentForm parent form
+     */
+    flatten(parent, current, containerRef, parentForm, depth) {
+        if (this.hasProperty(current, 'ComplexId')) {
+            const section = current;
+            if (parent.Operation === current.Operation) {
+                this.flatten(parent, section.LeftNode, containerRef, parentForm, depth);
+                this.flatten(parent, section.RightNode, containerRef, parentForm, depth);
+            }
+            else {
+                const result = this.createSection(section.Operation, containerRef, parentForm, depth);
+                this.flatten(section, section.LeftNode, result.containerRef, result.parentForm, depth + 1);
+                this.flatten(section, section.RightNode, result.containerRef, result.parentForm, depth + 1);
+            }
+        }
+        else if (this.hasProperty(current, 'ExpressionId')) {
+            this.createItem(current, containerRef, parentForm);
+        }
+    }
+    /**
+     * creates a container object of two or more child filter items
+     * @param operator AND/OR operator
+     * @param containerRef parent element
+     * @param parentForm parent form
+     * @param depth
+     * @returns an object containing the current element and current form
+     */
+    createSection(operator, containerRef, parentForm, depth) {
+        const factory = this._resolver.resolveComponentFactory(FilterBuilderSectionComponent);
+        let componentRef = containerRef.createComponent(factory);
+        let sectionGroup = this._fb.group({
+            operator: this._fb.control(operator)
+        });
+        let counter = 1;
+        Object.keys(parentForm.controls).forEach(item => { if (item.includes('section')) {
+            counter++;
+        } });
+        let formKey = `section${counter}`;
+        parentForm.addControl(formKey, sectionGroup);
+        componentRef.instance.depth = depth;
+        componentRef.instance.form = sectionGroup;
+        componentRef.instance.remove.subscribe(() => {
+            parentForm.removeControl(formKey);
+            componentRef.destroy();
+            this.createOutputJson();
+        });
+        componentRef.instance.operatorChange.subscribe(() => {
+            this.createOutputJson();
+        });
+        return {
+            containerRef: componentRef.instance.sectionContainer,
+            parentForm: sectionGroup
+        };
+    }
+    /**
+     * creates a component represents filter item (leaf element - has no childs)
+     * @param current filter legacy element
+     * @param containerRef parent element
+     * @param parentForm parent form
+     */
+    createItem(current, containerRef, parentForm) {
+        const factory = this._resolver.resolveComponentFactory(FilterBuilderItemComponent);
+        let componentRef = containerRef.createComponent(factory);
+        let counter = 1;
+        Object.keys(parentForm.controls).forEach(item => { if (item.includes('item')) {
+            counter++;
+        } });
+        let formKey = `item${counter}`;
+        componentRef.instance.formKey = formKey;
+        componentRef.instance.fields = this._smartFilterFields;
+        const selectedField = this.getSelectedField(current);
+        if (selectedField) {
+            componentRef.instance.selected = selectedField;
+            if (current) {
+                componentRef.instance.filter = this.getFilter(current, selectedField);
+            }
+        }
+        componentRef.instance.parentForm = parentForm;
+        componentRef.instance.filterChange.subscribe(() => {
+            this.createOutputJson();
+        });
+        componentRef.instance.remove.subscribe(() => {
+            parentForm.removeControl(formKey);
+            componentRef.destroy();
+            this.createOutputJson();
+        });
+    }
+    /**
+     * creates a smart filter object
+     * @param current filter legacy element
+     * @param field filter's selected field
+     * @returns smart filter object
+     */
+    getFilter(current, field) {
+        let operator = getSmartBuilderOperator(current.Operation, field.type);
+        if (operator) {
+            let filterValues = this.getFilterValues(current, operator, field);
+            return createSmartFilter(current.ApiName, operator, filterValues.first, filterValues.second, filterValues.operationUnit);
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * get smart filter field
+     * @param current filter legacy element
+     * @returns smart filter field, if not found returns the first fields
+     */
+    getSelectedField(current) {
+        var _a, _b;
+        if (current) {
+            let item = this._smartFilterFields.find(field => field.id === current.ApiName);
+            return item ? item : ((_a = this._smartFilterFields) === null || _a === void 0 ? void 0 : _a.length) > 0 ? this._smartFilterFields[0] : null;
+        }
+        else {
+            return ((_b = this._smartFilterFields) === null || _b === void 0 ? void 0 : _b.length) > 0 ? this._smartFilterFields[0] : null;
+        }
+    }
+    /**
+     * gets smart filter's values data
+     * @param current filter legacy element
+     * @param operator smart filter operator
+     * @param field filter's selected field
+     * @returns object contains the filter values data
+     */
+    getFilterValues(current, operator, field) {
+        var _a, _b, _c, _d, _e;
+        let data = {
+            first: null,
+            second: null,
+            operationUnit: null
+        };
+        if (operator === PepSmartFilterOperators.In) { //multi select                        
+            //filter keys don't exist on field options
+            data.first = ((_a = current === null || current === void 0 ? void 0 : current.Values) === null || _a === void 0 ? void 0 : _a.length) > 0 ? current.Values.filter(item => {
+                return field.options.find(option => option.key === item);
+            }) : null;
+        }
+        else if (operator === PepSmartFilterOperators.InTheLast ||
+            operator === PepSmartFilterOperators.NotInTheLast ||
+            operator === PepSmartFilterOperators.DueIn ||
+            operator === PepSmartFilterOperators.NotDueIn) { //operation unit
+            data.first = ((_b = current === null || current === void 0 ? void 0 : current.Values) === null || _b === void 0 ? void 0 : _b.length) > 0 ? current.Values[0] : null;
+            if (((_c = current === null || current === void 0 ? void 0 : current.Values) === null || _c === void 0 ? void 0 : _c.length) === 2) {
+                data.operationUnit = getSmartBuilderOperationUnit(current.Values[1]);
+            }
+        }
+        else {
+            data.first = ((_d = current === null || current === void 0 ? void 0 : current.Values) === null || _d === void 0 ? void 0 : _d.length) > 0 ? current.Values[0] : null;
+            data.second = ((_e = current === null || current === void 0 ? void 0 : current.Values) === null || _e === void 0 ? void 0 : _e.length) === 2 ? current.Values[1] : null;
+        }
+        return data;
+    }
+    /**
+     * converts legacy fields to smart filter fields
+     * @param fields legacy fields array
+     * @returns smart filter fields array
+     */
+    convertToSmartFilterFields(fields) {
+        if ((fields === null || fields === void 0 ? void 0 : fields.length) > 0) {
+            const typeMapper = new PepFilterBuilderTypeMap();
+            return fields.map((field) => {
+                var _a;
+                return createSmartFilterField({
+                    id: field.FieldID,
+                    name: field.Title,
+                    options: (_a = field.OptionalValues) === null || _a === void 0 ? void 0 : _a.map(option => {
+                        return {
+                            key: option.Key,
+                            value: option.Value
+                        };
+                    })
+                }, typeMapper.getSmartBuilderType(field.FieldType));
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * creates a legacy output JSON
+     */
+    createOutputJson() {
+        if (this._form.valid) {
+            const json = this._outputJsonService.generateJson(this._form.value, this._smartFilterFields);
+            this._outputJsonSubject.next(json);
+        }
+    }
+}
+FilterBuilderService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FilterBuilderService_Factory() { return new FilterBuilderService(i0.ɵɵinject(i1.FormBuilder), i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i2.PepOutputFilterService)); }, token: FilterBuilderService, providedIn: "root" });
+FilterBuilderService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+FilterBuilderService.ctorParameters = () => [
+    { type: FormBuilder },
+    { type: ComponentFactoryResolver },
+    { type: PepOutputFilterService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-builder.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-lib/smart-filters/filter-builder/filter-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Injectable, ViewContainerRef, ComponentFactoryResolver,\n    ComponentFactory, ComponentRef\n} from '@angular/core';\nimport { FormBuilder, FormGroup, AbstractControl, Validators } from '@angular/forms';\nimport { BehaviorSubject } from 'rxjs';\nimport { } from 'lodash';\nimport { PepSmartFiltersModule } from '../smart-filters.module';\nimport { IPepField, IPepJSONSection, IPepJSONItem } from './common/model/legacy';\nimport { PepSmartFilterBaseField, IPepSmartFilterField, IPepSmartFilterFieldOption } from '../common/model/field';\nimport { IPepSmartFilterData } from '../common/model/filter';\nimport { PepSmartFilterOperators, IPepSmartFilterOperator } from '../common/model/operator';\nimport { PepSmartFilterType } from '../common/model/type'\nimport { createSmartFilter, createSmartFilterField } from '../common/model/creator';\n//import { getSmartBuilderType } from './common/model/type';\n//import { convertToSmartFilterFields } from './common/model/field';\nimport { getSmartBuilderOperator } from './common/model/operator';\nimport { FilterBuilderSectionComponent } from './filter-builder-section/filter-builder-section.component';\nimport { FilterBuilderItemComponent } from './filter-builder-item/filter-builder-item.component';\nimport { PepFilterBuilderTypeMap } from './common/model/type-map';\nimport { getSmartBuilderOperationUnit } from './common/model/operator-unit';\n//import { PepFilterBuilderOperatorUnitMap } from './common/model/operator-unit-map';\nimport { PepOutputFilterService } from './common/services/output-filter.service';\nimport { IPepFilterBuilderValues } from './common/model/filter';\nimport { PepOperatorTypes } from './common/model/type';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FilterBuilderService {\n    private readonly MAX_STRUCTURE_DEPTH: number = 3;\n\n    private _outputJsonSubject = new BehaviorSubject<any>(null);\n\n    private _smartFilterFields: Array<IPepSmartFilterField>;\n    private _form: FormGroup;\n\n    public triggerOutputJson = this._outputJsonSubject.asObservable();\n\n    constructor(private _fb: FormBuilder, private _resolver: ComponentFactoryResolver, private _outputJsonService: PepOutputFilterService) {\n\n    }\n\n    get maxDepth(): number {\n        return this.MAX_STRUCTURE_DEPTH;\n    }\n\n    /**\n     * creates a dynamic filter structure\n     * might has a different structure than the input's due to merge of parent-child elements\n     * @param json legacy JSON\n     * @param fields an array of legacy fields     \n     * @param containerRef reference to root element\n     */\n    createFilterTree(\n        json: IPepJSONSection | null,\n        fields: Array<IPepField>,\n        form: FormGroup,\n        containerRef: ViewContainerRef\n    ) {\n        this._form = form;\n        this._smartFilterFields = this.convertToSmartFilterFields(fields);\n        const result = this.createSection(json?.Operation ? json.Operation : PepOperatorTypes.And, containerRef, this._form, 0);\n        if (json) {\n            this.flatten(json, json.LeftNode, result.containerRef, result.parentForm, 1);\n            this.flatten(json, json.RightNode, result.containerRef, result.parentForm, 1);\n        }\n    }\n\n    /**\n    * checks if the object contains property\n    * @param obj object\n    * @param prop property name\n    * @returns true if contains, false otherwise\n    */\n    private hasProperty(obj, prop) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    }\n\n    /**\n     * a recursive function dynamically builds filters structure\n     * @param parent legacy complex object\n     * @param current child legacy object (either another complex or expression type)\n     * @param containerRef parent element\n     * @param parentForm parent form\n     */\n    private flatten(parent: IPepJSONSection, current: IPepJSONSection | IPepJSONItem, containerRef: ViewContainerRef, parentForm: FormGroup, depth: number) {\n        if (this.hasProperty(current, 'ComplexId')) {\n            const section = current as IPepJSONSection;\n            if (parent.Operation === current.Operation) {\n                this.flatten(parent, section.LeftNode, containerRef, parentForm, depth);\n                this.flatten(parent, section.RightNode, containerRef, parentForm, depth);\n            } else {\n                const result = this.createSection(section.Operation, containerRef, parentForm, depth);\n                this.flatten(section, section.LeftNode, result.containerRef, result.parentForm, depth + 1);\n                this.flatten(section, section.RightNode, result.containerRef, result.parentForm, depth + 1);\n            }\n        } else if (this.hasProperty(current, 'ExpressionId')) {\n            this.createItem(current as IPepJSONItem, containerRef, parentForm);\n        }\n    }\n\n    /**\n     * creates a container object of two or more child filter items\n     * @param operator AND/OR operator\n     * @param containerRef parent element\n     * @param parentForm parent form\n     * @param depth\n     * @returns an object containing the current element and current form\n     */\n    createSection(operator: PepOperatorTypes, containerRef: ViewContainerRef, parentForm: FormGroup, depth: number) {\n        const factory = this._resolver.resolveComponentFactory(FilterBuilderSectionComponent);\n        let componentRef = containerRef.createComponent(factory);\n\n        let sectionGroup = this._fb.group({\n            operator: this._fb.control(operator)\n        });\n        let counter = 1;\n        Object.keys(parentForm.controls).forEach(item => { if (item.includes('section')) { counter++; } });\n        let formKey: string = `section${counter}`;\n        parentForm.addControl(formKey, sectionGroup);\n\n        componentRef.instance.depth = depth;\n        componentRef.instance.form = sectionGroup;\n        componentRef.instance.remove.subscribe(() => {\n            parentForm.removeControl(formKey);\n            componentRef.destroy();\n            this.createOutputJson();\n        });\n        componentRef.instance.operatorChange.subscribe(() => {\n            this.createOutputJson();\n        });\n\n        return {\n            containerRef: componentRef.instance.sectionContainer,\n            parentForm: sectionGroup\n        };\n    }\n\n    /**\n     * creates a component represents filter item (leaf element - has no childs)\n     * @param current filter legacy element\n     * @param containerRef parent element\n     * @param parentForm parent form\n     */\n    createItem(current: IPepJSONItem, containerRef: ViewContainerRef, parentForm: FormGroup) {\n        const factory = this._resolver.resolveComponentFactory(FilterBuilderItemComponent);\n        let componentRef = containerRef.createComponent(factory);\n\n        let counter = 1;\n        Object.keys(parentForm.controls).forEach(item => { if (item.includes('item')) { counter++; } });\n        let formKey: string = `item${counter}`;\n\n        componentRef.instance.formKey = formKey;\n        componentRef.instance.fields = this._smartFilterFields;\n        const selectedField = this.getSelectedField(current);\n        if (selectedField) {\n            componentRef.instance.selected = selectedField;\n            if (current) {\n                componentRef.instance.filter = this.getFilter(current, selectedField);\n            }\n        }\n        componentRef.instance.parentForm = parentForm;\n        componentRef.instance.filterChange.subscribe(() => {\n            this.createOutputJson();\n        });\n        componentRef.instance.remove.subscribe(() => {\n            parentForm.removeControl(formKey);\n            componentRef.destroy();\n            this.createOutputJson();\n        });\n    }\n\n    /**\n     * creates a smart filter object\n     * @param current filter legacy element\n     * @param field filter's selected field\n     * @returns smart filter object\n     */\n    private getFilter(current: IPepJSONItem, field: any): IPepSmartFilterData | null {\n        let operator: IPepSmartFilterOperator = getSmartBuilderOperator(current.Operation, field.type);\n        if (operator) {\n            let filterValues: IPepFilterBuilderValues = this.getFilterValues(current, operator, field);\n            return createSmartFilter(\n                current.ApiName,\n                operator,\n                filterValues.first,\n                filterValues.second,\n                filterValues.operationUnit\n            );\n        } else {\n            return null;\n        }\n    }\n\n    /**\n     * get smart filter field\n     * @param current filter legacy element\n     * @returns smart filter field, if not found returns the first fields\n     */\n    private getSelectedField(current: IPepJSONItem): IPepSmartFilterField | null {\n        if (current) {\n            let item = this._smartFilterFields.find(field => field.id === current.ApiName);\n            return item ? item : this._smartFilterFields?.length > 0 ? this._smartFilterFields[0] : null;\n        } else {\n            return this._smartFilterFields?.length > 0 ? this._smartFilterFields[0] : null;\n        }\n    }\n\n    /**\n     * gets smart filter's values data\n     * @param current filter legacy element\n     * @param operator smart filter operator\n     * @param field filter's selected field\n     * @returns object contains the filter values data\n     */\n    private getFilterValues(current: IPepJSONItem, operator: IPepSmartFilterOperator, field: any) {\n        let data: IPepFilterBuilderValues = {\n            first: null,\n            second: null,\n            operationUnit: null\n        };\n\n        if (operator === PepSmartFilterOperators.In) { //multi select                        \n            //filter keys don't exist on field options\n            data.first = current?.Values?.length > 0 ? current.Values.filter(item => {\n                return field.options.find(option => option.key === item);\n            }) : null;\n        } else if (\n            operator === PepSmartFilterOperators.InTheLast ||\n            operator === PepSmartFilterOperators.NotInTheLast ||\n            operator === PepSmartFilterOperators.DueIn ||\n            operator === PepSmartFilterOperators.NotDueIn\n        ) { //operation unit\n            data.first = current?.Values?.length > 0 ? current.Values[0] : null;\n            if (current?.Values?.length === 2) {\n                data.operationUnit = getSmartBuilderOperationUnit(current.Values[1]);\n            }\n        } else {\n            data.first = current?.Values?.length > 0 ? current.Values[0] : null;\n            data.second = current?.Values?.length === 2 ? current.Values[1] : null;\n        }\n\n        return data;\n    }\n\n    /**\n     * converts legacy fields to smart filter fields\n     * @param fields legacy fields array\n     * @returns smart filter fields array\n     */\n    private convertToSmartFilterFields(fields: Array<IPepField>) {\n        if (fields?.length > 0) {\n            const typeMapper = new PepFilterBuilderTypeMap();\n            return fields.map((field) => {\n                return createSmartFilterField(\n                    {\n                        id: field.FieldID,\n                        name: field.Title,\n                        options: field.OptionalValues?.map(option => {\n                            return {\n                                key: option.Key,\n                                value: option.Value\n                            }\n                        })\n                    } as IPepSmartFilterField\n                    , typeMapper.getSmartBuilderType(field.FieldType) as PepSmartFilterType)\n            })\n        } else {\n            return [];\n        }\n    }\n\n    /**\n     * creates a legacy output JSON \n     */\n    private createOutputJson() {\n        if (this._form.valid) {\n            const json = this._outputJsonService.generateJson(this._form.value, this._smartFilterFields);\n            this._outputJsonSubject.next(json);\n        }\n    }\n\n\n\n}"]}

package/esm2015/smart-filters/index.js

@@ -0,0 +1,5 @@
+/*
+ * export from ngx-lib/smart-filters
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGliL3NtYXJ0LWZpbHRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBleHBvcnQgZnJvbSBuZ3gtbGliL3NtYXJ0LWZpbHRlcnNcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==