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

package/smart-filters/boolean-filter/boolean-filter.component.d.ts

@@ -1,7 +1,11 @@
+import { OnInit } from '@angular/core';
 import { BaseFilterComponent } from '../common/model/base-filter-component';
 import { IPepSmartFilterOperator } from '../common/model/operator';
 import { IPepSmartFilterDataValue } from '../common/model/filter';
-export declare class PepBooleanFilterComponent extends BaseFilterComponent {
+export declare class PepBooleanFilterComponent extends BaseFilterComponent implements OnInit {
+    ngOnInit(): void;
     getDefaultOperator(): IPepSmartFilterOperator;
     getFilterValue(): IPepSmartFilterDataValue;
+    onRadioChanged(): void;
+    onValueChanged(value: any): void;
 }

package/smart-filters/common/model/base-filter-component.d.ts

@@ -5,6 +5,7 @@ import { IPepSmartFilterOperator, IPepSmartFilterOperatorUnit } from './operator
 import { IPepSmartFilterData, IPepSmartFilterDataValue } from './filter';
 import { PepSmartFilterBaseField } from './field';
 import { TranslateService } from '@ngx-translate/core';
+import { PepTypeConvertorService } from '../../filter-builder/common/services/type-convertor.service';
 export declare abstract class BaseFilterComponent implements OnInit, OnChanges, OnDestroy {
     private viewContainerRef;
     private injector;
@@ -13,6 +14,7 @@ export declare abstract class BaseFilterComponent implements OnInit, OnChanges,
     protected translate: TranslateService;
     protected validator: PepValidatorService;
     protected renderer: Renderer2;
+    typeConvertorService: PepTypeConvertorService;
     private readonly _destroyed;
     private actionsContainerRef;
     private _fieldIdWithNoDots;
@@ -22,6 +24,12 @@ export declare abstract class BaseFilterComponent implements OnInit, OnChanges,
     private _filter;
     set filter(value: IPepSmartFilterData);
     get filter(): IPepSmartFilterData;
+    protected _parentForm: FormGroup;
+    set parentForm(form: FormGroup);
+    emitOnChange: boolean;
+    inline: boolean;
+    showActionButtons: boolean;
+    renderTitle: boolean;
     filterClear: EventEmitter<void>;
     filterChange: EventEmitter<IPepSmartFilterData>;
     private _operator;
@@ -39,11 +47,12 @@ export declare abstract class BaseFilterComponent implements OnInit, OnChanges,
     protected readonly OPERATORS_TRANSLATION_PREFIX = "SMART_FILTERS.OPERATORS";
     protected readonly OPERATOR_UNITS_TRANSLATION_PREFIX = "SMART_FILTERS.OPERATOR_UNITS";
     form: FormGroup;
-    constructor(viewContainerRef: ViewContainerRef, injector: Injector, resolver: ComponentFactoryResolver, builder: FormBuilder, translate: TranslateService, validator: PepValidatorService, renderer: Renderer2);
+    constructor(viewContainerRef: ViewContainerRef, injector: Injector, resolver: ComponentFactoryResolver, builder: FormBuilder, translate: TranslateService, validator: PepValidatorService, renderer: Renderer2, typeConvertorService: PepTypeConvertorService);
     private createActionsComponent;
     private setupForm;
     private setupOperators;
     private setupFilter;
+    protected updateParentForm(): void;
     protected getDestroyer(): import("rxjs").MonoTypeOperatorFunction<unknown>;
     private updateValidity;
     protected loadOperatorsOptions(): void;

package/smart-filters/common/model/field.d.ts

@@ -25,6 +25,10 @@ export declare abstract class PepSmartFilterBaseField implements IPepSmartFilter
     constructor(field: IPepSmartFilterField);
     protected abstract getType(): PepSmartFilterType;
 }
+export declare class PepSmartFilterTextField extends PepSmartFilterBaseField {
+    constructor(field: IPepSmartFilterField);
+    getType(): PepSmartFilterType;
+}
 export declare class PepSmartFilterBooleanField extends PepSmartFilterBaseField {
     constructor(field: IPepSmartFilterField);
     getType(): PepSmartFilterType;

package/smart-filters/common/model/operator.d.ts

@@ -11,6 +11,7 @@ export declare const PepSmartFilterOperators: {
     LessThan: IPepSmartFilterOperator;
     GreaterThan: IPepSmartFilterOperator;
     NumberRange: IPepSmartFilterOperator;
+    Contains: IPepSmartFilterOperator;
     InTheLast: IPepSmartFilterOperator;
     Today: IPepSmartFilterOperator;
     ThisWeek: IPepSmartFilterOperator;

package/smart-filters/common/model/type.d.ts

@@ -1,4 +1,4 @@
-export declare type PepSmartFilterComponentType = 'number' | 'date' | 'multi-select' | 'boolean';
-export declare type PepSmartFilterType = 'boolean' | 'currency' | 'date' | 'date-time' | 'int' | 'multi-select' | 'percentage' | 'real';
+export declare type PepSmartFilterComponentType = 'text' | 'number' | 'date' | 'multi-select' | 'boolean';
+export declare type PepSmartFilterType = 'text' | 'boolean' | 'currency' | 'date' | 'date-time' | 'int' | 'multi-select' | 'percentage' | 'real';
 export declare type PepSmartFilterOperatorType = 'eq' | 'neq' | 'lt' | 'gt' | 'ltoe' | 'gtoe' | 'numberRange' | 'contains' | 'beginsWith' | 'endsWith' | 'after' | 'before' | 'inTheLast' | 'today' | 'thisWeek' | 'thisMonth' | 'dateRange' | 'dueIn' | 'on' | 'notInTheLast' | 'notDueIn' | 'isEmpty' | 'isNotEmpty' | 'in';
 export declare type PepSmartFilterOperatorUnitType = 'days' | 'weeks' | 'months' | 'years';

package/smart-filters/date-filter/date-filter.component.d.ts

@@ -1,14 +1,16 @@
+import { OnInit } from '@angular/core';
 import { BaseFilterComponent } from '../common/model/base-filter-component';
 import { IPepSmartFilterOperator, IPepSmartFilterOperatorUnit } from '../common/model/operator';
 import { IPepSmartFilterDataValue } from '../common/model/filter';
 import { IPepOption } from '@pepperi-addons/ngx-lib';
-export declare class PepDateFilterComponent extends BaseFilterComponent {
+export declare class PepDateFilterComponent extends BaseFilterComponent implements OnInit {
     PepSmartFilterOperators: {
         Equals: IPepSmartFilterOperator;
         NotEqual: IPepSmartFilterOperator;
         LessThan: IPepSmartFilterOperator;
         GreaterThan: IPepSmartFilterOperator;
         NumberRange: IPepSmartFilterOperator;
+        Contains: IPepSmartFilterOperator;
         InTheLast: IPepSmartFilterOperator;
         Today: IPepSmartFilterOperator;
         ThisWeek: IPepSmartFilterOperator;
@@ -24,11 +26,16 @@ export declare class PepDateFilterComponent extends BaseFilterComponent {
     };
     chooseTimeOptions: Array<IPepOption>;
     chooseTimeUnitOptions: Array<IPepOption>;
+    operatorWidth: string;
+    fieldsWidth: string;
+    ngOnInit(): void;
     getDefaultOperator(): IPepSmartFilterOperator;
     getDefaultOperatorUnit(): IPepSmartFilterOperatorUnit;
     getFilterValue(): IPepSmartFilterDataValue;
     loadOperatorsOptions(): void;
     setFieldsStateAndValidators(): void;
+    setControlsWidth(): void;
     onOperatorChanged(value: string): void;
     onTimeUnitChanged(value: string): void;
+    onDateValueChanged(): void;
 }

package/smart-filters/filter-builder/common/model/filter.d.ts

@@ -0,0 +1,6 @@
+import { IPepSmartFilterOperatorUnit } from '../../../common/model/operator';
+export interface IPepFilterBuilderValues {
+    first: any;
+    second: any;
+    operationUnit: IPepSmartFilterOperatorUnit;
+}

package/smart-filters/filter-builder/common/model/legacy.d.ts

@@ -0,0 +1,23 @@
+import { PepOperatorTypes } from './type';
+export interface IPepField {
+    FieldID: string;
+    FieldType: string;
+    Title: string;
+    OptionalValues: IPepFieldOptionalValues[];
+}
+export interface IPepFieldOptionalValues {
+    Key: string;
+    Value: string;
+}
+export interface IPepJSONSection {
+    ComplexId: string;
+    Operation: PepOperatorTypes;
+    LeftNode?: IPepJSONSection | IPepJSONItem;
+    RightNode?: IPepJSONSection | IPepJSONItem;
+}
+export interface IPepJSONItem {
+    ExpressionId: string;
+    ApiName: string;
+    Operation: string;
+    Values: any[];
+}

package/smart-filters/filter-builder/common/model/operator-unit.d.ts

@@ -0,0 +1,13 @@
+import { IPepSmartFilterOperatorUnit } from '../../../common/model/operator';
+/**
+ * gets a smart filter operation unit item
+ * @param operationUnit legacy operation unit
+ * @returns smart filter operation unit item
+ */
+export declare function getSmartBuilderOperationUnit(operationUnit: string): IPepSmartFilterOperatorUnit | null;
+/**
+ * gets a legacy operation unit value
+ * @param operationUnit smart filter operation unit item
+ * @returns legacy operation unit value
+ */
+export declare function getLegacyOperationUnit(operationUnit: IPepSmartFilterOperatorUnit): string | null;

package/smart-filters/filter-builder/common/model/operator.d.ts

@@ -0,0 +1,21 @@
+import { IPepSmartFilterOperator } from '../../../common/model/operator';
+import { PepSmartFilterType } from '../../../common/model/type';
+export interface IPepFilterBuilderOperator {
+    legacy: string;
+    smartFilter: IPepSmartFilterOperator;
+    type: PepSmartFilterType[] | null;
+}
+/**
+ * gets a smart filter operator item
+ * @param operator legacy operator
+ * @param type smart filter's type
+ * @returns smart filter operator item
+ */
+export declare function getSmartBuilderOperator(operator: string, type: PepSmartFilterType): IPepSmartFilterOperator | null;
+/**
+ * gets a legacy operator value
+ * @param operator smart filter operator item
+ * @param type smart filter's type
+ * @returns legacy operator value
+ */
+export declare function getLegacyOperator(operator: IPepSmartFilterOperator, type: PepSmartFilterType): string | null;

package/smart-filters/filter-builder/common/model/type-map.d.ts

@@ -0,0 +1,12 @@
+import { PepSmartFilterType } from '../../../common/model/type';
+export declare class PepFilterBuilderTypeMap {
+    private map;
+    constructor();
+    private loadTypes;
+    /**
+     * Converts legacy field type to smart builder type
+     * @param type legacy type
+     * @returns smart builder field type
+     */
+    getSmartBuilderType(key: string): PepSmartFilterType | null;
+}

package/smart-filters/filter-builder/common/model/type.d.ts

@@ -0,0 +1,4 @@
+export declare enum PepOperatorTypes {
+    And = "AND",
+    Or = "OR"
+}

package/smart-filters/filter-builder/common/pipes/filter-item-counter.pipe.d.ts

@@ -0,0 +1,5 @@
+import { PipeTransform } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+export declare class FilterItemCounterPipe implements PipeTransform {
+    transform(container: FormGroup): number;
+}

package/smart-filters/filter-builder/common/services/output-filter.service.d.ts

@@ -0,0 +1,52 @@
+import { IPepSmartFilterField } from 'projects/ngx-lib/smart-filters';
+export declare class PepOutputFilterService {
+    private _json;
+    private _fields;
+    private _firstItem;
+    private _complexIdCounter;
+    private _expressionIdCounter;
+    constructor();
+    /**
+     * generates a legacy JSON
+     * @param json UI smart filters structure
+     * @param fields smart filter field
+     * @returns legacy JSON
+     */
+    generateJson(json: any, fields: Array<IPepSmartFilterField>): any;
+    /**
+     * reset properties
+     */
+    private initProperties;
+    /**
+     * a recursive function dynamically builds legacy JSON structure
+     * @param current UI object represents either a section or filter component
+     */
+    private treeWalk;
+    /**
+     * adds a filter to json and wrap it with complex operator
+     * @param item expression item
+     * @param operator complex operator
+     */
+    private createItem;
+    /**
+     * creates a legacy complex object
+     * @param left LeftNode object
+     * @param right RightNode object
+     * @param operator AND/OR operator
+     * @returns complex object
+     */
+    private createSection;
+    /**
+     * gets legacy filter values object
+     * @param current UI filter object's values
+     * @returns an array represents legacy values
+     */
+    private getItemValues;
+    /**
+     * generates an array of keys of multi-select control
+     * @param values an array of the selected values
+     * @param id filter's selected field
+     * @returns an array of keys
+     */
+    private getFieldKeys;
+}

package/smart-filters/filter-builder/common/services/type-convertor.service.d.ts

@@ -0,0 +1,10 @@
+import { IPepOption } from '@pepperi-addons/ngx-lib';
+export declare class PepTypeConvertorService {
+    private readonly _operators;
+    private readonly _booleans;
+    get operators(): IPepOption[];
+    get booleans(): IPepOption[];
+    constructor();
+    private initOperators;
+    private initBooleans;
+}

package/smart-filters/filter-builder/filter-builder-item/filter-builder-item.component.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { PepSmartFilterBaseField, IPepSmartFilterField } from '../../common/model/field';
+import { IPepSmartFilterData } from '../../common/model/filter';
+import { IPepOption } from '@pepperi-addons/ngx-lib';
+export declare class FilterBuilderItemComponent {
+    private _fb;
+    formKey: string;
+    _fields: Array<any>;
+    _options: IPepOption[];
+    set fields(list: Array<IPepSmartFilterField>);
+    _selectedField: PepSmartFilterBaseField;
+    set selected(value: any);
+    _filter: IPepSmartFilterData;
+    set filter(value: IPepSmartFilterData);
+    _parentForm: FormGroup;
+    set parentForm(value: FormGroup);
+    filterChange: EventEmitter<any>;
+    remove: EventEmitter<any>;
+    test: any;
+    _form: FormGroup;
+    fieldWidth: number;
+    filterWidth: number;
+    binWidth: number;
+    constructor(_fb: FormBuilder);
+    ngOnInit(): void;
+    setupForm(): void;
+    addToParentForm(): void;
+    onFieldChanged(key: any): void;
+    onFilterChanged(): void;
+    onDeleteItemClicked(): void;
+}

package/smart-filters/filter-builder/filter-builder-section/filter-builder-section.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, ViewContainerRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FilterBuilderService } from '../filter-builder.service';
+import { PepTypeConvertorService } from '../common/services/type-convertor.service';
+export declare class FilterBuilderSectionComponent {
+    filterBuilderService: FilterBuilderService;
+    typeConvertorService: PepTypeConvertorService;
+    form: FormGroup;
+    depth: number;
+    remove: EventEmitter<any>;
+    operatorChange: EventEmitter<any>;
+    sectionContainer: ViewContainerRef;
+    constructor(filterBuilderService: FilterBuilderService, typeConvertorService: PepTypeConvertorService);
+    ngOnInit(): void;
+    get f(): {
+        [key: string]: import("@angular/forms").AbstractControl;
+    };
+    onOperatorChanged(value: any): void;
+    onAddRuleClicked(): void;
+    onAddRuleSetClicked(): void;
+    onDeleteSectionClicked(): void;
+}

package/smart-filters/filter-builder/filter-builder-section/filter-builder-section.component.theme.scss

@@ -0,0 +1,6 @@
+@mixin pep-filter-builder-section-theme($pepperi-theme) {
+    .filter-section-container {
+        box-shadow: get-pep-shadow($pepperi-theme, shadow-md, soft);       
+        @include border(border, 1px, solid, get-pep-color($pepperi-theme, color-system-primary, color-tran-50)); 
+    }
+}

package/smart-filters/filter-builder/filter-builder.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnInit, OnDestroy, ViewContainerRef } from '@angular/core';
+import { IPepField, IPepJSONSection } from './common/model/legacy';
+import { FilterBuilderService } from './filter-builder.service';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import { Subscription } from 'rxjs';
+export declare class FilterBuilderComponent implements OnInit, OnDestroy {
+    private _fb;
+    private _filterBuilderService;
+    json: IPepJSONSection;
+    fields: Array<IPepField>;
+    filters: EventEmitter<any>;
+    formValidationChange: EventEmitter<boolean>;
+    filterRoot: ViewContainerRef;
+    _formSubscription$: Subscription;
+    _outputJsonSubscription$: Subscription;
+    _isFormValid: boolean;
+    form: FormGroup;
+    constructor(_fb: FormBuilder, _filterBuilderService: FilterBuilderService);
+    setupForm(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+}

package/smart-filters/filter-builder/filter-builder.service.d.ts

@@ -0,0 +1,90 @@
+import { ViewContainerRef, ComponentFactoryResolver } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { IPepField, IPepJSONSection, IPepJSONItem } from './common/model/legacy';
+import { PepOutputFilterService } from './common/services/output-filter.service';
+import { PepOperatorTypes } from './common/model/type';
+export declare class FilterBuilderService {
+    private _fb;
+    private _resolver;
+    private _outputJsonService;
+    private readonly MAX_STRUCTURE_DEPTH;
+    private _outputJsonSubject;
+    private _smartFilterFields;
+    private _form;
+    triggerOutputJson: import("rxjs").Observable<any>;
+    constructor(_fb: FormBuilder, _resolver: ComponentFactoryResolver, _outputJsonService: PepOutputFilterService);
+    get maxDepth(): number;
+    /**
+     * 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: IPepJSONSection | null, fields: Array<IPepField>, form: FormGroup, containerRef: ViewContainerRef): void;
+    /**
+    * checks if the object contains property
+    * @param obj object
+    * @param prop property name
+    * @returns true if contains, false otherwise
+    */
+    private hasProperty;
+    /**
+     * 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
+     */
+    private flatten;
+    /**
+     * 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: PepOperatorTypes, containerRef: ViewContainerRef, parentForm: FormGroup, depth: number): {
+        containerRef: ViewContainerRef;
+        parentForm: FormGroup;
+    };
+    /**
+     * 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: IPepJSONItem, containerRef: ViewContainerRef, parentForm: FormGroup): void;
+    /**
+     * creates a smart filter object
+     * @param current filter legacy element
+     * @param field filter's selected field
+     * @returns smart filter object
+     */
+    private getFilter;
+    /**
+     * get smart filter field
+     * @param current filter legacy element
+     * @returns smart filter field, if not found returns the first fields
+     */
+    private getSelectedField;
+    /**
+     * 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
+     */
+    private getFilterValues;
+    /**
+     * converts legacy fields to smart filter fields
+     * @param fields legacy fields array
+     * @returns smart filter fields array
+     */
+    private convertToSmartFilterFields;
+    /**
+     * creates a legacy output JSON
+     */
+    private createOutputJson;
+}

package/smart-filters/index.d.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/smart-filters/multi-select-filter/multi-select-filter.component.d.ts

@@ -2,6 +2,7 @@ import { AfterViewInit, ElementRef } from '@angular/core';
 import { OnInit } from '@angular/core';
 import { BaseFilterComponent } from '../common/model/base-filter-component';
 import { IPepSmartFilterOperator } from '../common/model/operator';
+import { IPepOption } from '@pepperi-addons/ngx-lib';
 import { IPepSmartFilterDataValue } from '../common/model/filter';
 import { IPepSmartFilterFieldOption } from '../common/model/field';
 import { Observable } from 'rxjs';
@@ -16,12 +17,16 @@ export declare class PepMultiSelectFilterComponent extends BaseFilterComponent i
     options: PepMultiSelectFilterOption[];
     filteredOptions$: Observable<any>;
     searchControl: FormControl;
+    selected: string;
+    inlineOptions: IPepOption[];
     optionsContainer: ElementRef;
     private readonly MAX_OPTIONS_TO_SHOW;
     private virtualScroller;
     numberOptionsToShowSearch: number;
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    private inlineControlInit;
+    private noneInlineControlInit;
     initOptionsSelectedValues(selectedValues: string[]): void;
     private calcOptionsHeight;
     private filterOptions;
@@ -29,5 +34,6 @@ export declare class PepMultiSelectFilterComponent extends BaseFilterComponent i
     getFilterValue(): IPepSmartFilterDataValue;
     initFilter(): void;
     onOptionChange(option: PepMultiSelectFilterOption, event: MatCheckboxChange): void;
+    onMultiSelectChanged(value: string): void;
 }
 export {};

package/smart-filters/number-filter/number-filter.component.d.ts

@@ -10,6 +10,7 @@ export declare class PepNumberFilterComponent extends BaseFilterComponent implem
         LessThan: IPepSmartFilterOperator;
         GreaterThan: IPepSmartFilterOperator;
         NumberRange: IPepSmartFilterOperator;
+        Contains: IPepSmartFilterOperator;
         InTheLast: IPepSmartFilterOperator;
         Today: IPepSmartFilterOperator;
         ThisWeek: IPepSmartFilterOperator;
@@ -24,10 +25,14 @@ export declare class PepNumberFilterComponent extends BaseFilterComponent implem
         In: IPepSmartFilterOperator;
     };
     chooseTypeOptions: Array<IPepOption>;
+    operatorWidth: string;
+    firstControlWidth: string;
     ngOnInit(): void;
     getDefaultOperator(): IPepSmartFilterOperator;
     getFilterValue(): IPepSmartFilterDataValue;
     loadOperatorsOptions(): void;
     setFieldsStateAndValidators(): void;
+    setControlsWidth(): void;
     onOperatorChanged(value: string): void;
+    onValueChanged(): void;
 }

package/smart-filters/pepperi-addons-ngx-lib-smart-filters.d.ts

@@ -2,3 +2,10 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public-api';
+export { FilterItemCounterPipe as ɵg } from './filter-builder/common/pipes/filter-item-counter.pipe';
+export { PepOutputFilterService as ɵb } from './filter-builder/common/services/output-filter.service';
+export { PepTypeConvertorService as ɵd } from './filter-builder/common/services/type-convertor.service';
+export { FilterBuilderItemComponent as ɵf } from './filter-builder/filter-builder-item/filter-builder-item.component';
+export { FilterBuilderSectionComponent as ɵe } from './filter-builder/filter-builder-section/filter-builder-section.component';
+export { FilterBuilderService as ɵa } from './filter-builder/filter-builder.service';
+export { PepTextFilterComponent as ɵc } from './text-filter/text-filter.component';