@pepperi-addons/ngx-composite-lib 0.4.2-beta.96 → 0.5.0-ng15.1

package/esm2020/mapping-parameters/mapping-parameters.component.mjs

@@ -0,0 +1,44 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { PepMappingParametersService } from './mapping-parameters.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./mapping-parameters.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./param-map/param-map.component";
+import * as i4 from "@ngx-translate/core";
+export class PepMappingParametersComponent {
+    constructor(_mappingParametersService) {
+        this._mappingParametersService = _mappingParametersService;
+        this.mapToParameters = {};
+        this.configurationParameters = [];
+        this.mappedParameters = {};
+        this.maxHeight = '100%';
+        this.mappedParamValueChanged = new EventEmitter();
+    }
+    ngOnInit() {
+        this._mappingParametersService.initParametersByType(this.mapToParameters);
+    }
+    onMappedParamValueChanged(event, key) {
+        if (!this.mappedParameters) {
+            this.mappedParameters = {};
+        }
+        this.mappedParameters[key] = event;
+        this.mappedParamValueChanged.emit(this.mappedParameters);
+    }
+}
+PepMappingParametersComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersComponent, deps: [{ token: i1.PepMappingParametersService }], target: i0.ɵɵFactoryTarget.Component });
+PepMappingParametersComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: PepMappingParametersComponent, selector: "pep-mapping-parameters", inputs: { mapToParameters: "mapToParameters", configurationParameters: "configurationParameters", mappedParameters: "mappedParameters", maxHeight: "maxHeight" }, outputs: { mappedParamValueChanged: "mappedParamValueChanged" }, providers: [PepMappingParametersService], ngImport: i0, template: "<div class=\"header-title pep-border-bottom\">\n    <span class=\"body-md bold\">{{'MAPPING_PARAMETERS.VARIABLE_MAPPING' | translate}}</span>\n</div>\n<div class=\"params-container\" [style.max-height]=\"maxHeight\">\n    <ng-container *ngFor=\"let configParam of configurationParameters\">\n        <param-map \n            [configurationParameter]=\"configParam\" \n            [mappedParam]=\"mappedParameters && mappedParameters[configParam.Key]\" \n            (mappedParamValueChanged)=\"onMappedParamValueChanged($event, configParam.Key)\">\n        </param-map>\n    </ng-container>\n</div>\n", styles: [".header-title{height:var(--pep-form-field-height, 2.5rem);display:flex;margin-bottom:var(--pep-spacing-md, .75rem);align-items:center}.params-container{overflow:auto}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i3.ParamMapComponent, selector: "param-map", inputs: ["configurationParameter", "mappedParam"], outputs: ["mappedParamValueChanged"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pep-mapping-parameters', providers: [PepMappingParametersService], template: "<div class=\"header-title pep-border-bottom\">\n    <span class=\"body-md bold\">{{'MAPPING_PARAMETERS.VARIABLE_MAPPING' | translate}}</span>\n</div>\n<div class=\"params-container\" [style.max-height]=\"maxHeight\">\n    <ng-container *ngFor=\"let configParam of configurationParameters\">\n        <param-map \n            [configurationParameter]=\"configParam\" \n            [mappedParam]=\"mappedParameters && mappedParameters[configParam.Key]\" \n            (mappedParamValueChanged)=\"onMappedParamValueChanged($event, configParam.Key)\">\n        </param-map>\n    </ng-container>\n</div>\n", styles: [".header-title{height:var(--pep-form-field-height, 2.5rem);display:flex;margin-bottom:var(--pep-spacing-md, .75rem);align-items:center}.params-container{overflow:auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PepMappingParametersService }]; }, propDecorators: { mapToParameters: [{
+                type: Input
+            }], configurationParameters: [{
+                type: Input
+            }], mappedParameters: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], mappedParamValueChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/mapping-parameters/mapping-parameters.model.mjs

@@ -0,0 +1,6 @@
+/**
+ * Interface for mapping parameters
+ */
+// export type ListParameter = Record<string, any>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcGluZy1wYXJhbWV0ZXJzLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWNvbXBvc2l0ZS1saWIvbWFwcGluZy1wYXJhbWV0ZXJzL21hcHBpbmctcGFyYW1ldGVycy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILG1EQUFtRCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSW50ZXJmYWNlIGZvciBtYXBwaW5nIHBhcmFtZXRlcnNcbiAqL1xuLy8gZXhwb3J0IHR5cGUgTGlzdFBhcmFtZXRlciA9IFJlY29yZDxzdHJpbmcsIGFueT47XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWFwcGVkUGFyYW1ldGVyIHtcbiAgICAvLyBLZXk6IHN0cmluZztcbiAgICBWYWx1ZTogc3RyaW5nO1xuICAgIFR5cGU6ICdEZWZhdWx0JyB8ICdTdGF0aWMnIHwgJ0R5bmFtaWMnO1xufVxuXG5leHBvcnQgdHlwZSBNYXBwZWRQYXJhbWV0ZXJzID0gUmVjb3JkPHN0cmluZywgTWFwcGVkUGFyYW1ldGVyPjsiXX0=

package/esm2020/mapping-parameters/mapping-parameters.module.mjs

@@ -0,0 +1,59 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PepButtonModule } from '@pepperi-addons/ngx-lib/button';
+import { PepCheckboxModule } from '@pepperi-addons/ngx-lib/checkbox';
+import { TranslateModule } from '@ngx-translate/core';
+import { PepSliderModule } from '@pepperi-addons/ngx-lib/slider';
+import { PepNgxLibModule } from '@pepperi-addons/ngx-lib';
+import { PepGroupButtonsModule } from '@pepperi-addons/ngx-lib/group-buttons';
+import { PepSelectModule } from '@pepperi-addons/ngx-lib/select';
+import { PepMappingParametersComponent } from './mapping-parameters.component';
+import { PepTextboxModule } from '@pepperi-addons/ngx-lib/textbox';
+import { ParamMapComponent } from './param-map/param-map.component';
+import { PepMappingParametersService } from './mapping-parameters.service';
+import { PepGenericFormModule } from '@pepperi-addons/ngx-composite-lib/generic-form';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class PepMappingParametersModule {
+}
+PepMappingParametersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PepMappingParametersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersModule, declarations: [PepMappingParametersComponent, ParamMapComponent], imports: [CommonModule,
+        PepButtonModule,
+        PepCheckboxModule,
+        PepSliderModule,
+        PepNgxLibModule,
+        PepSelectModule,
+        PepGroupButtonsModule,
+        PepTextboxModule,
+        PepGenericFormModule, i1.TranslateModule], exports: [PepMappingParametersComponent] });
+PepMappingParametersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersModule, providers: [PepMappingParametersService], imports: [CommonModule,
+        PepButtonModule,
+        PepCheckboxModule,
+        PepSliderModule,
+        PepNgxLibModule,
+        PepSelectModule,
+        PepGroupButtonsModule,
+        PepTextboxModule,
+        PepGenericFormModule,
+        TranslateModule.forChild()] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [PepMappingParametersComponent, ParamMapComponent],
+                    imports: [
+                        CommonModule,
+                        PepButtonModule,
+                        PepCheckboxModule,
+                        PepSliderModule,
+                        PepNgxLibModule,
+                        PepSelectModule,
+                        PepGroupButtonsModule,
+                        PepTextboxModule,
+                        PepGenericFormModule,
+                        TranslateModule.forChild()
+                    ],
+                    exports: [PepMappingParametersComponent],
+                    providers: [PepMappingParametersService]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/mapping-parameters/mapping-parameters.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+// export const SELECTION_FIELD_PREFIX = 'ValueSelectionType_';
+export class PepMappingParametersService {
+    constructor() {
+        this._parametersByType = new Map();
+    }
+    get parametersByType() {
+        return this._parametersByType;
+    }
+    //constructor() {}
+    initParametersByType(parameters) {
+        this._parameters = parameters || {};
+        Object.keys(this._parameters).forEach(key => {
+            const param = this._parameters ? this._parameters[key] : undefined;
+            if (!param) {
+                return;
+            }
+            if (!this._parametersByType.has(param.Type)) {
+                this._parametersByType.set(param.Type, []);
+            }
+            this._parametersByType.get(param.Type)?.push({
+                key: key,
+                value: key
+            });
+        });
+    }
+    getParametersOptions(type) {
+        return this._parametersByType.get(type) || [];
+    }
+}
+PepMappingParametersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepMappingParametersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepMappingParametersService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapping-parameters.service.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/mapping-parameters/mapping-parameters.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAG3C,+DAA+D;AAG/D,MAAM,OAAO,2BAA2B;IADxC;QASY,sBAAiB,GAAuC,IAAI,GAAG,EAAiC,CAAC;KA0R5G;IAzRG,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAClC,CAAC;IAED,kBAAkB;IAElB,oBAAoB,CAAC,UAAqC;QACtD,IAAI,CAAC,WAAW,GAAG,UAAU,IAAI,EAAE,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACxC,MAAM,KAAK,GAA4B,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC5F,IAAI,CAAC,KAAK,EAAE;gBACR,OAAO;aACV;YAED,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;gBACzC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;aAC9C;YAED,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;gBACzC,GAAG,EAAE,GAAG;gBACR,KAAK,EAAE,GAAG;aACb,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAED,oBAAoB,CAAC,IAAqB;QACtC,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IAClD,CAAC;;yHApCQ,2BAA2B;6HAA3B,2BAA2B;4FAA3B,2BAA2B;kBADvC,UAAU","sourcesContent":["import { AddonDataScheme, DataViewFieldType, FlowParam, SchemeField, SchemeFieldType } from \"@pepperi-addons/papi-sdk\";\nimport { Injectable } from \"@angular/core\";\nimport { IPepOption } from \"@pepperi-addons/ngx-lib\";\n\n// export const SELECTION_FIELD_PREFIX = 'ValueSelectionType_';\n\n@Injectable()\nexport class PepMappingParametersService {\n\n    // configParams: IParamemeter[] = []\n\n    // variablesMap: {\n    //     [key: string]: Set<string>\n    // } = {};\n    private _parameters: AddonDataScheme['Fields'];\n    private _parametersByType: Map<SchemeFieldType, IPepOption[]> = new Map<SchemeFieldType, IPepOption[]>();\n    get parametersByType(): ReadonlyMap<SchemeFieldType, IPepOption[]> {\n        return this._parametersByType;\n    }\n\n    //constructor() {}\n\n    initParametersByType(parameters: AddonDataScheme['Fields']) {\n        this._parameters = parameters || {};\n        Object.keys(this._parameters).forEach(key => {\n            const param: SchemeField | undefined = this._parameters ? this._parameters[key] : undefined;\n            if (!param) {\n                return;\n            }\n\n            if (!this._parametersByType.has(param.Type)) {\n                this._parametersByType.set(param.Type, []);\n            }\n            \n            this._parametersByType.get(param.Type)?.push({\n                key: key,\n                value: key\n            });\n        });\n    }\n\n    getParametersOptions(type: SchemeFieldType): IPepOption[] {\n        return this._parametersByType.get(type) || [];\n    }\n        \n    \n    // private initVariables(hostParams: AddonDataScheme['Fields']) {\n    //     const params = hostParams || {};\n    //     Object.keys(params).forEach(name => {\n    //         const param = params[name];\n    //         if(!this.variablesMap.hasOwnProperty(param.Type)) {\n    //             this.variablesMap[param.Type] = new Set<string>();\n    //         }\n    //         this.variablesMap[param.Type].add(name);\n    //     })\n    // }\n    \n    // private getDefaultValueForType(paramType: SchemeFieldType): any {\n    //     let defaultValue;\n    //     switch (paramType) {\n    //         case 'Bool':{\n    //             defaultValue = false;\n    //             break;\n    //         }\n    //         case 'Integer':{\n    //             defaultValue = 0;\n    //             break;\n    //         }\n    //         case 'Double': {\n    //             defaultValue = 0.0;\n    //             break;\n    //         }\n    //         case 'Object': {\n    //             defaultValue = '{}';\n    //             break;\n    //         }\n    //         default: {\n    //             defaultValue = ''\n    //         }\n    //     }\n    //     return defaultValue; \n    // }\n\n    // private getFieldsFromConfigParams(configParams: IParamemeter[], formData: Record<string, any>): IPepGenericFormDataViewField[] {\n    //     const viewFields: IPepGenericFormDataViewField[] = [{\n    //         Type: 'Separator',\n    //         FieldID: '',\n    //         OptionalValues: [],\n    //         AdditionalProps: {},\n    //         Mandatory: false,\n    //         ReadOnly: true,\n    //         Title: '', //this.translate.instant('FlowPicker_ParamsSection_Title'),\n    //         Layout: {\n    //             Origin: {\n    //                 X: 0,\n    //                 Y: 0\n    //             },\n    //             Size: {\n    //                 Width: 2,\n    //                 Height:0\n    //             }\n    //         }\n    //     }];\n    //     (configParams).filter(param => !param.Internal).forEach((param, index) => {\n    //         const fieldID = `${SELECTION_FIELD_PREFIX}${param.Key}`;\n    //         const pair = this.getParamDataViewFields(param, index + 1, formData[fieldID]);\n    //         viewFields.push(...pair);\n    //     })\n    //     return viewFields;\n    // }\n    \n    // private getParamDataViewFields(param: IParamemeter, index: number, fieldSelection: string): IPepGenericFormDataViewField[]{\n    //     const fieldID = `${SELECTION_FIELD_PREFIX}${param.Key}`;\n    //     const variableNames: KeyValuePair<string>[] = this.getVariablesForType(param.Type);\n    //     const valueSelectionOptions: KeyValuePair<string>[] = [{\n    //         Key: 'static', \n    //         Value: 'Static'\n    //     }]\n    //     if(param.DefaultValue) {\n    //         valueSelectionOptions.push({\n    //             Key: 'default',\n    //             Value: 'Default'\n    //         })\n    //     }\n    //     if(variableNames?.length > 0) {\n    //         valueSelectionOptions.push({\n    //             Key: 'dynamic',\n    //             Value: 'Dynamic'\n    //         })\n    //     }\n    //     return [{\n    //         FieldID: fieldID,\n    //         Mandatory: false,\n    //         ReadOnly: false,\n    //         Title: param.Key,\n    //         Type:'ComboBox',\n    //         Layout: {\n    //             Origin: {\n    //                 X: 0,\n    //                 Y: index\n    //             },\n    //             Size: {\n    //                 Width: 1,\n    //                 Height: 0\n    //             }\n    //         },\n    //         Style: {\n    //             Alignment: {\n    //                 Horizontal: 'Stretch',\n    //                 Vertical: 'Stretch'\n    //             }\n    //         },\n    //         OptionalValues: valueSelectionOptions,\n    //         AdditionalProps: {\n    //             emptyOption: false\n    //         }\n    //     }, {\n    //         FieldID: param.Key,\n    //         Mandatory: false,\n    //         ReadOnly: fieldSelection === 'default',\n    //         Title: param.Key,\n    //         Type: fieldSelection != 'dynamic' ? this.convertParamsTypeToDVType(param.Type): 'ComboBox',\n    //         Layout: {\n    //             Origin: {\n    //                 X: 1,\n    //                 Y: index\n    //             },\n    //             Size: {\n    //                 Width: 1,\n    //                 Height: 0\n    //             }\n    //         },\n    //         Style: {\n    //             Alignment: {\n    //                 Horizontal: 'Stretch',\n    //                 Vertical: 'Stretch'\n    //             }\n    //         },\n    //         OptionalValues: fieldSelection === 'dynamic' ? variableNames : [],\n    //         AdditionalProps: {\n    //             emptyOption: false\n    //         }\n    //     }]\n    // }\n\n    // private convertParamsTypeToDVType(paramType: SchemeFieldType): DataViewFieldType {\n    //     let res: DataViewFieldType = 'TextBox';\n    //     switch (paramType) {\n    //         case 'Bool': {\n    //             res = 'Boolean';\n    //             break;\n    //         }\n    //         case 'Integer': {\n    //             res = 'NumberInteger';\n    //             break;\n    //         }\n    //         case 'Double': {\n    //             res = 'NumberReal';\n    //             break;\n    //         }\n    //     }\n    //     return res;\n    // }\n\n    // private getVariablesForType(paramType: SchemeFieldType): KeyValuePair<string>[] {\n    //     const result: KeyValuePair<string>[] = []\n    //     const variables = this.variablesMap[paramType];\n    //     if(variables) {\n    //         for (const item of variables.entries()){\n    //             result.push({\n    //                 Key: item[1],\n    //                 Value: item[1]\n    //             })\n    //         }\n    //     }\n\n    //     return result;\n    // }\n\n    // handleFieldChanged(event: IPepGenericFormValueChange, currentFormData: Record<string, any>) {\n    //     let newValue = ''\n    //     if(event.ApiName.startsWith(SELECTION_FIELD_PREFIX)) {\n    //         const paramName = event.ApiName.substring(SELECTION_FIELD_PREFIX.length);\n    //         const param = this.configParams.find(x=> x.Key === paramName);\n    //         if(event.Value === 'default') {\n    //             newValue = param?.DefaultValue;\n    //         }\n    //         else {\n    //             newValue = this.getDefaultValueForType(param?.Type as SchemeFieldType);\n    //         }\n    //         currentFormData[paramName] = newValue;\n    //     }\n    //     return currentFormData;\n    // }\n\n    // getFormData(FlowParamsObject?: Record<string, any>, configParams: IParamemeter[] = []): Record<string, any> {\n    //     this.configParams = configParams;\n    //     return configParams.filter(param => !param.Internal).map((param): Record<string, any> => {\n    //         const result: Record<string, any> = {};\n    //         const formPropName = `${SELECTION_FIELD_PREFIX}${param.Key}`;\n    //         if (FlowParamsObject) {\n    //             const data = FlowParamsObject[param.Name];\n    //             if(data) {\n    //                 switch (data.Source) {\n    //                     case 'Dynamic': {\n    //                         result[formPropName] = 'dynamic';\n    //                         break;\n    //                     }\n    //                     case 'Static': {\n    //                         result[formPropName] = 'static'\n    //                         break;\n    //                     }\n    //                 }\n    //                 result[param.Key] = data.Value;\n    //             }\n    //         }\n    //         if (!result[formPropName]) {\n    //             result[param.Key] = param?.DefaultValue ? param.DefaultValue : this.getDefaultValueForType(param.Type);\n    //             result[formPropName] = param?.DefaultValue ? 'default': 'static';\n    //         }\n    //         return result;\n    //     }).reduce((prev, current) => {\n    //         prev = {...prev, ...current};\n    //         return prev;\n    //     }, {})\n    // }\n\n    // getRunFlowParamsData(formData: Record<string, any>): Record<string, any> {\n    //     const result: Record<string, any> = {}\n    //     Object.keys(formData).forEach(prop => {\n    //         if (prop.startsWith(SELECTION_FIELD_PREFIX)) {\n    //             const paramName = prop.substring(SELECTION_FIELD_PREFIX.length);\n    //             const value = {\n    //                 Source: formData[prop] === 'dynamic' ? 'Dynamic' : 'Static',\n    //                 Value: formData[paramName]\n    //             }\n    //             result[paramName] = value;\n    //         }\n    //     })\n    //     return result;\n    // }\n\n    // getPickerFormView(configParams: IParamemeter[], hostParams: AddonDataScheme['Fields'], formData: Record<string, any>): IPepGenericFormDataView {\n    //     this.initVariables(hostParams);\n    //     const result: IPepGenericFormDataView = {\n    //         Type: 'Form',\n    //         Fields: [],\n    //         Columns: [{},{}],\n    //         Context: {\n    //             Name: '',\n    //             Profile: { },\n    //             ScreenSize: 'Tablet'\n    //         }\n    //     };\n    //     result.Fields = this.getFieldsFromConfigParams(configParams, formData);\n    //     return result;\n    // }\n}"]}

package/esm2020/mapping-parameters/param-map/param-map.component.mjs

@@ -0,0 +1,73 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../mapping-parameters.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@pepperi-addons/ngx-lib/select";
+import * as i5 from "@pepperi-addons/ngx-lib/textbox";
+export class ParamMapComponent {
+    set mappedParam(value) {
+        this._mappedParam = value;
+        this.initParam();
+    }
+    get mappedParam() {
+        return this._mappedParam;
+    }
+    constructor(translate, _mappingParametersService) {
+        this.translate = translate;
+        this._mappingParametersService = _mappingParametersService;
+        this.mappedParamValueChanged = new EventEmitter();
+        this.parametersByType = [];
+        this.paramTypes = [];
+        this.paramHasDefaultValue = false;
+        this.param = {
+            Value: '',
+            Type: 'Static'
+        };
+    }
+    initParam() {
+        this.paramHasDefaultValue = !!this.configurationParameter?.DefaultValue;
+        this.param.Type = this.mappedParam?.Type || (this.paramHasDefaultValue ? 'Default' : 'Static');
+        this.param.Value = this.mappedParam?.Value || this.configurationParameter?.DefaultValue;
+        if (this.param.Type !== this.mappedParam?.Type ||
+            this.param.Value !== this.mappedParam?.Value) {
+            this.mappedParamValueChanged.emit(this.param);
+        }
+    }
+    ngOnInit() {
+        // Get the parameters options by type from the service.
+        this.parametersByType = this._mappingParametersService.getParametersOptions(this.configurationParameter.Type);
+        this.initParam();
+        this.paramTypes = [
+            { key: 'Static', value: this.translate.instant('MAPPING_PARAMETERS.STATIC') },
+        ];
+        if (this.paramHasDefaultValue) {
+            this.paramTypes.push({ key: 'Default', value: this.translate.instant('MAPPING_PARAMETERS.DEFAULT') });
+        }
+        if (this.parametersByType.length > 0) {
+            this.paramTypes.push({ key: 'Dynamic', value: this.translate.instant('MAPPING_PARAMETERS.DYNAMIC') });
+        }
+    }
+    onParamKeyChanged(event) {
+        this.param.Type = event;
+        this.param.Value = event === 'Default' ? this.configurationParameter?.DefaultValue : event === 'Static' ? '' : '';
+        this.mappedParamValueChanged.emit(this.param);
+    }
+    onParamValueChanged(event) {
+        this.param.Value = event;
+        this.mappedParamValueChanged.emit(this.param);
+    }
+}
+ParamMapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ParamMapComponent, deps: [{ token: i1.TranslateService }, { token: i2.PepMappingParametersService }], target: i0.ɵɵFactoryTarget.Component });
+ParamMapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ParamMapComponent, selector: "param-map", inputs: { configurationParameter: "configurationParameter", mappedParam: "mappedParam" }, outputs: { mappedParamValueChanged: "mappedParamValueChanged" }, ngImport: i0, template: "<div class=\"paramMapCont\">\n    <pep-select\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Type\"\n        [options]=\"paramTypes\"\n        [emptyOption]=\"false\"\n        (valueChange)=\"onParamKeyChanged($event)\"\n    ></pep-select>\n    <pep-textbox\n        *ngIf=\"!(param.Type === 'Dynamic')\"\n        [label]=\"configurationParameter.Key\"\n        [disabled]=\"param.Type !== 'Static'\"\n        [value]=\"param.Value\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-textbox>\n\n    <pep-select\n        *ngIf=\"param.Type === 'Dynamic'\"\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Value\"\n        [options]=\"parametersByType\"\n        [emptyOption]=\"true\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-select>\n</div>\n", styles: [".paramMapCont{display:grid;grid-template-columns:1fr 1fr;gap:var(--pep-spacing-lg, 1rem)}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PepSelectComponent, selector: "pep-select", inputs: ["key", "value", "label", "type", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "placeholder", "placeholderWhenDisabled", "autoSortOptions", "options", "visible", "emptyOption", "form", "layoutType", "parentFieldKey", "isActive", "showTitle", "renderTitle", "typeaheadDebounceInterval", "addValueToOptionsIfNotExist"], outputs: ["valueChange", "validationChange"] }, { kind: "component", type: i5.PepTextboxComponent, selector: "pep-textbox", inputs: ["key", "value", "minFractionDigits", "maxFractionDigits", "accessory", "label", "placeholder", "type", "mandatory", "disabled", "readonly", "maxFieldCharacters", "hint", "textColor", "xAlignment", "rowSpan", "minValue", "maxValue", "visible", "form", "isActive", "showTitle", "renderTitle", "renderError", "renderSymbol", "layoutType", "parentFieldKey", "regex", "regexError", "isInFocus"], outputs: ["valueChange", "keyup", "validationChange"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ParamMapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'param-map', template: "<div class=\"paramMapCont\">\n    <pep-select\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Type\"\n        [options]=\"paramTypes\"\n        [emptyOption]=\"false\"\n        (valueChange)=\"onParamKeyChanged($event)\"\n    ></pep-select>\n    <pep-textbox\n        *ngIf=\"!(param.Type === 'Dynamic')\"\n        [label]=\"configurationParameter.Key\"\n        [disabled]=\"param.Type !== 'Static'\"\n        [value]=\"param.Value\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-textbox>\n\n    <pep-select\n        *ngIf=\"param.Type === 'Dynamic'\"\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Value\"\n        [options]=\"parametersByType\"\n        [emptyOption]=\"true\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-select>\n</div>\n", styles: [".paramMapCont{display:grid;grid-template-columns:1fr 1fr;gap:var(--pep-spacing-lg, 1rem)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.PepMappingParametersService }]; }, propDecorators: { configurationParameter: [{
+                type: Input
+            }], mappedParam: [{
+                type: Input
+            }], mappedParamValueChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-map.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-composite-lib/mapping-parameters/param-map/param-map.component.ts","../../../../../projects/ngx-composite-lib/mapping-parameters/param-map/param-map.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Output, OnInit } from '@angular/core';\nimport { MappedParameter } from '../mapping-parameters.model';\nimport { TranslateService } from '@ngx-translate/core';\nimport { IParamemeter } from '@pepperi-addons/ngx-composite-lib/manage-parameters';\nimport { PepMappingParametersService } from '../mapping-parameters.service';\nimport { IPepOption } from '@pepperi-addons/ngx-lib';\n\n@Component({\n    selector: 'param-map',\n    templateUrl: './param-map.component.html',\n    styleUrls: ['./param-map.component.scss']\n})\nexport class ParamMapComponent implements OnInit {\n\n    @Input() configurationParameter!: IParamemeter;\n\n    private _mappedParam: MappedParameter | undefined;\n    @Input()\n    set mappedParam(value: MappedParameter | undefined) {\n        this._mappedParam = value;\n        this.initParam();\n    }\n    get mappedParam(): MappedParameter | undefined {\n        return this._mappedParam;\n    }\n    \n    @Output() mappedParamValueChanged: EventEmitter<MappedParameter> = new EventEmitter()\n\n    protected parametersByType: IPepOption[] = [];\n    protected paramTypes: any[] = [];\n\n    protected paramHasDefaultValue = false;\n    protected param: MappedParameter = {\n        Value: '',\n        Type: 'Static'\n    }\n\n    constructor(\n        private translate: TranslateService,\n        private _mappingParametersService: PepMappingParametersService\n    ) {}\n\n    private initParam() {\n        this.paramHasDefaultValue = !!this.configurationParameter?.DefaultValue;\n        this.param.Type = this.mappedParam?.Type || (this.paramHasDefaultValue ? 'Default' : 'Static');\n        this.param.Value = this.mappedParam?.Value || this.configurationParameter?.DefaultValue;\n\n        if (this.param.Type !== this.mappedParam?.Type ||\n            this.param.Value !== this.mappedParam?.Value\n        ) {\n            this.mappedParamValueChanged.emit(this.param);\n        }\n    }\n\n    ngOnInit() {\n        // Get the parameters options by type from the service.\n        this.parametersByType = this._mappingParametersService.getParametersOptions(this.configurationParameter.Type);\n        this.initParam();\n\n        this.paramTypes = [\n            { key: 'Static', value: this.translate.instant('MAPPING_PARAMETERS.STATIC') },\n        ];\n        \n        if (this.paramHasDefaultValue) {\n            this.paramTypes.push({ key: 'Default', value: this.translate.instant('MAPPING_PARAMETERS.DEFAULT') });\n        }\n\n        if (this.parametersByType.length > 0) {\n            this.paramTypes.push({ key: 'Dynamic', value: this.translate.instant('MAPPING_PARAMETERS.DYNAMIC') });\n        }\n    }\n\n    onParamKeyChanged(event: any) {\n        this.param.Type = event;\n        this.param.Value = event === 'Default' ? this.configurationParameter?.DefaultValue : event === 'Static' ? '' : '';\n\n        this.mappedParamValueChanged.emit(this.param);\n    }\n\n    onParamValueChanged(event: any) {\n        this.param.Value = event;\n        this.mappedParamValueChanged.emit(this.param);\n    }\n}\n","<div class=\"paramMapCont\">\n    <pep-select\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Type\"\n        [options]=\"paramTypes\"\n        [emptyOption]=\"false\"\n        (valueChange)=\"onParamKeyChanged($event)\"\n    ></pep-select>\n    <pep-textbox\n        *ngIf=\"!(param.Type === 'Dynamic')\"\n        [label]=\"configurationParameter.Key\"\n        [disabled]=\"param.Type !== 'Static'\"\n        [value]=\"param.Value\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-textbox>\n\n    <pep-select\n        *ngIf=\"param.Type === 'Dynamic'\"\n        [label]=\"configurationParameter.Key\"\n        [value]=\"param.Value\"\n        [options]=\"parametersByType\"\n        [emptyOption]=\"true\"\n        (valueChange)=\"onParamValueChanged($event)\"\n    ></pep-select>\n</div>\n"]}

package/esm2020/mapping-parameters/pepperi-addons-ngx-composite-lib-mapping-parameters.mjs

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

package/esm2020/mapping-parameters/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './mapping-parameters.model';
+export * from './mapping-parameters.component';
+export * from './mapping-parameters.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL21hcHBpbmctcGFyYW1ldGVycy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYXBwaW5nLXBhcmFtZXRlcnMubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXBwaW5nLXBhcmFtZXRlcnMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbWFwcGluZy1wYXJhbWV0ZXJzLm1vZHVsZSc7XG4iXX0=

package/esm2020/ngx-composite-lib.module.mjs

@@ -20,17 +20,17 @@ export class PepNgxCompositeLibModule {
         ]);
     }
 }
-PepNgxCompositeLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepNgxCompositeLibModule, deps: [{ token: i1.PepIconRegistry }], target: i0.ɵɵFactoryTarget.NgModule });
-PepNgxCompositeLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.2", ngImport: i0, type: PepNgxCompositeLibModule, declarations: [PepResetConfigurationFieldDirective], imports: [CommonModule,
+PepNgxCompositeLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepNgxCompositeLibModule, deps: [{ token: i1.PepIconRegistry }], target: i0.ɵɵFactoryTarget.NgModule });
+PepNgxCompositeLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: PepNgxCompositeLibModule, declarations: [PepResetConfigurationFieldDirective], imports: [CommonModule,
         PepIconModule,
         PepRemoteLoaderModule], exports: [PepResetConfigurationFieldDirective] });
-PepNgxCompositeLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepNgxCompositeLibModule, providers: [
+PepNgxCompositeLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepNgxCompositeLibModule, providers: [
         PepDIMXHelperService,
         PepCompositeLibUtilitiesService
     ], imports: [CommonModule,
         PepIconModule,
         PepRemoteLoaderModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: PepNgxCompositeLibModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepNgxCompositeLibModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -51,4 +51,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImpor
                     ]
                 }]
         }], ctorParameters: function () { return [{ type: i1.PepIconRegistry }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/padding-settings/padding-settings.component.mjs

@@ -0,0 +1,90 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { PepPaddingSettings } from './padding-settings.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/common";
+import * as i3 from "@pepperi-addons/ngx-lib/checkbox";
+import * as i4 from "@pepperi-addons/ngx-lib/textbox";
+export class PaddingSettingsComponent {
+    set padding(value) {
+        if (!value) {
+            this._padding = new PepPaddingSettings();
+        }
+        else {
+            this._padding = value;
+        }
+        this.formatPaddingValue();
+    }
+    get padding() {
+        return this._padding;
+    }
+    constructor(translate) {
+        this.translate = translate;
+        this.startPaddingValue = '0';
+        this.endPaddingValue = '0';
+        this.topPaddingValue = '0';
+        this.bottomPaddingValue = '0';
+        this._padding = new PepPaddingSettings();
+        this.paddingChange = new EventEmitter();
+    }
+    raisePaddingChange() {
+        this.paddingChange.emit(this.padding);
+    }
+    onUniformChanged(value) {
+        this.padding.IsUniform = value;
+        this.formatPaddingValue();
+        this.raisePaddingChange();
+    }
+    formatPaddingValue() {
+        if (this.padding.IsUniform) {
+            this.padding.PaddingValue = this.padding.PaddingValue.split(',')[0];
+        }
+        else {
+            if (isNaN(Number(this.padding.PaddingValue))) {
+                const num = this.padding.PaddingValue.split(',') || ['0', '0', '0', '0'];
+                this.topPaddingValue = num[0];
+                this.endPaddingValue = num[1];
+                this.bottomPaddingValue = num[2];
+                this.startPaddingValue = num[3];
+            }
+            else {
+                this.topPaddingValue = this.endPaddingValue = this.bottomPaddingValue = this.startPaddingValue = this.padding.PaddingValue;
+            }
+            this.padding.PaddingValue = `${this.topPaddingValue},${this.endPaddingValue},${this.bottomPaddingValue},${this.startPaddingValue}`;
+        }
+    }
+    onPaddingChanged(value, uniformPos) {
+        if (!this.padding.IsUniform) {
+            switch (uniformPos) {
+                case 'top':
+                    this.topPaddingValue = value;
+                    break;
+                case 'end':
+                    this.endPaddingValue = value;
+                    break;
+                case 'bottom':
+                    this.bottomPaddingValue = value;
+                    break;
+                case 'start':
+                    this.startPaddingValue = value;
+                    break;
+            }
+            this.padding.PaddingValue = `${this.topPaddingValue},${this.endPaddingValue},${this.bottomPaddingValue},${this.startPaddingValue}`;
+        }
+        else {
+            this.padding.PaddingValue = `${value}`;
+        }
+        this.raisePaddingChange();
+    }
+}
+PaddingSettingsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PaddingSettingsComponent, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+PaddingSettingsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: PaddingSettingsComponent, selector: "pep-padding-settings", inputs: { padding: "padding" }, outputs: { paddingChange: "paddingChange" }, ngImport: i0, template: "<div>\n    <label class=\"body-xl bold ellipsis title\">{{'PADDING_SETTINGS.TITLE' | translate}}</label>\n    <pep-checkbox \n        class=\"checkbox-as-sub-title\"\n        [label]=\"'PADDING_SETTINGS.UNIFORM' | translate\" \n        [renderTitle]=\"false\" \n        [value]=\"padding?.IsUniform || false\" \n        (valueChange)=\"onUniformChanged($event)\">\n    </pep-checkbox>\n    <div class=\"paddingValueCont\">\n        <pep-textbox *ngIf=\"padding?.IsUniform\"\n            type=\"real\"\n            [label]=\"'PADDING_SETTINGS.DESCRIPTION' | translate\" \n            [value]=\"padding?.PaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'uniform')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\" \n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.TOP' | translate\" \n            [value]=\"topPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'top')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.END' | translate\" \n            [value]=\"endPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'end')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.BOTTOM' | translate\" \n            [value]=\"bottomPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'bottom')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.START' | translate\" \n            [value]=\"startPaddingValue || '0'\"\n            (valueChange)=\"onPaddingChanged($event, 'start')\">\n        </pep-textbox>\n    </div>\n</div>", styles: [":host{width:100%;display:grid}:host label{margin-bottom:0}pep-checkbox ::ng-deep .mat-checkbox-inner-container,pep-checkbox ::ng-deep .mat-mdc-checkbox-inner-container{width:1.25rem;height:1.25rem}.paddingValueCont{display:grid;column-gap:var(--pep-spacing-sm, .5rem);grid-auto-flow:column}.paddingValueCont ::ng-deep .mat-form-field-flex,.paddingValueCont ::ng-deep .mat-mdc-form-field-flex{padding-inline:.5rem}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.PepCheckboxComponent, selector: "pep-checkbox", inputs: ["key", "value", "label", "type", "mandatory", "disabled", "readonly", "xAlignment", "rowSpan", "additionalValue", "form", "isActive", "showTitle", "renderTitle", "layoutType", "visible"], outputs: ["valueChange", "validationChange"] }, { kind: "component", type: i4.PepTextboxComponent, selector: "pep-textbox", inputs: ["key", "value", "minFractionDigits", "maxFractionDigits", "accessory", "label", "placeholder", "type", "mandatory", "disabled", "readonly", "maxFieldCharacters", "hint", "textColor", "xAlignment", "rowSpan", "minValue", "maxValue", "visible", "form", "isActive", "showTitle", "renderTitle", "renderError", "renderSymbol", "layoutType", "parentFieldKey", "regex", "regexError", "isInFocus"], outputs: ["valueChange", "keyup", "validationChange"] }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PaddingSettingsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pep-padding-settings', template: "<div>\n    <label class=\"body-xl bold ellipsis title\">{{'PADDING_SETTINGS.TITLE' | translate}}</label>\n    <pep-checkbox \n        class=\"checkbox-as-sub-title\"\n        [label]=\"'PADDING_SETTINGS.UNIFORM' | translate\" \n        [renderTitle]=\"false\" \n        [value]=\"padding?.IsUniform || false\" \n        (valueChange)=\"onUniformChanged($event)\">\n    </pep-checkbox>\n    <div class=\"paddingValueCont\">\n        <pep-textbox *ngIf=\"padding?.IsUniform\"\n            type=\"real\"\n            [label]=\"'PADDING_SETTINGS.DESCRIPTION' | translate\" \n            [value]=\"padding?.PaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'uniform')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\" \n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.TOP' | translate\" \n            [value]=\"topPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'top')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.END' | translate\" \n            [value]=\"endPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'end')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.BOTTOM' | translate\" \n            [value]=\"bottomPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'bottom')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.START' | translate\" \n            [value]=\"startPaddingValue || '0'\"\n            (valueChange)=\"onPaddingChanged($event, 'start')\">\n        </pep-textbox>\n    </div>\n</div>", styles: [":host{width:100%;display:grid}:host label{margin-bottom:0}pep-checkbox ::ng-deep .mat-checkbox-inner-container,pep-checkbox ::ng-deep .mat-mdc-checkbox-inner-container{width:1.25rem;height:1.25rem}.paddingValueCont{display:grid;column-gap:var(--pep-spacing-sm, .5rem);grid-auto-flow:column}.paddingValueCont ::ng-deep .mat-form-field-flex,.paddingValueCont ::ng-deep .mat-mdc-form-field-flex{padding-inline:.5rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; }, propDecorators: { padding: [{
+                type: Input
+            }], paddingChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"padding-settings.component.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/padding-settings/padding-settings.component.ts","../../../../projects/ngx-composite-lib/padding-settings/padding-settings.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { PepPaddingSettings } from './padding-settings.model';\n\n@Component({\n    selector: 'pep-padding-settings',\n    templateUrl: './padding-settings.component.html',\n    styleUrls: ['./padding-settings.component.scss']\n})\n\nexport class PaddingSettingsComponent  {\n\n    public startPaddingValue = '0';\n    public endPaddingValue = '0';\n    public topPaddingValue = '0';\n    public bottomPaddingValue = '0';\n\n    private _padding: PepPaddingSettings = new PepPaddingSettings();\n    @Input()\n    set padding(value: PepPaddingSettings) {\n        if (!value) {\n            this._padding = new PepPaddingSettings();\n        } else {\n            this._padding = value;\n        }\n        this.formatPaddingValue();\n    }\n    get padding(): PepPaddingSettings {\n        return this._padding;\n    }\n\n    @Output()\n    paddingChange: EventEmitter<PepPaddingSettings> = new EventEmitter<PepPaddingSettings>();\n\n    constructor(\n        private translate: TranslateService,\n    ) {\n       \n    }\n\n    private raisePaddingChange() {\n        this.paddingChange.emit(this.padding);\n    }\n\n    onUniformChanged(value: boolean) {\n        this.padding.IsUniform = value;\n        this.formatPaddingValue();\n        this.raisePaddingChange();\n    }\n\n    formatPaddingValue() {\n        if(this.padding.IsUniform){ \n            this.padding.PaddingValue = this.padding.PaddingValue.split(',')[0];\n         } \n         else{\n            if(isNaN(Number(this.padding.PaddingValue))){\n                const num = this.padding.PaddingValue.split(',') || ['0','0','0','0'];\n                this.topPaddingValue = num[0];\n                this.endPaddingValue = num[1];\n                this.bottomPaddingValue = num[2];\n                this.startPaddingValue = num[3];\n            }\n            else{\n                this.topPaddingValue = this.endPaddingValue = this.bottomPaddingValue = this.startPaddingValue = this.padding.PaddingValue;\n            }\n            \n            this.padding.PaddingValue = `${this.topPaddingValue},${this.endPaddingValue},${this.bottomPaddingValue},${this.startPaddingValue}`;\n         } \n    }\n\n    onPaddingChanged(value: any, uniformPos: string) {\n        if(!this.padding.IsUniform){\n            switch(uniformPos){\n                case 'top':\n                    this.topPaddingValue = value;\n                    break;\n                case 'end':\n                    this.endPaddingValue = value;\n                    break;\n                case 'bottom':\n                    this.bottomPaddingValue = value;\n                    break;\n                case 'start':\n                    this.startPaddingValue = value;\n                    break;\n            }\n           this.padding.PaddingValue = `${this.topPaddingValue},${this.endPaddingValue},${this.bottomPaddingValue},${this.startPaddingValue}`;\n        }\n        else{\n            this.padding.PaddingValue = `${value}`;\n        }\n        this.raisePaddingChange();\n    }\n}\n","<div>\n    <label class=\"body-xl bold ellipsis title\">{{'PADDING_SETTINGS.TITLE' | translate}}</label>\n    <pep-checkbox \n        class=\"checkbox-as-sub-title\"\n        [label]=\"'PADDING_SETTINGS.UNIFORM' | translate\" \n        [renderTitle]=\"false\" \n        [value]=\"padding?.IsUniform || false\" \n        (valueChange)=\"onUniformChanged($event)\">\n    </pep-checkbox>\n    <div class=\"paddingValueCont\">\n        <pep-textbox *ngIf=\"padding?.IsUniform\"\n            type=\"real\"\n            [label]=\"'PADDING_SETTINGS.DESCRIPTION' | translate\" \n            [value]=\"padding?.PaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'uniform')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\" \n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.TOP' | translate\" \n            [value]=\"topPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'top')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.END' | translate\" \n            [value]=\"endPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'end')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.BOTTOM' | translate\" \n            [value]=\"bottomPaddingValue || '0'\" \n            (valueChange)=\"onPaddingChanged($event, 'bottom')\">\n        </pep-textbox>\n        <pep-textbox *ngIf=\"!padding?.IsUniform\"\n            type=\"real\"\n            [renderSymbol]=\"false\"\n            [label]=\"'PADDING_SETTINGS.START' | translate\" \n            [value]=\"startPaddingValue || '0'\"\n            (valueChange)=\"onPaddingChanged($event, 'start')\">\n        </pep-textbox>\n    </div>\n</div>"]}

package/esm2020/padding-settings/padding-settings.model.mjs

@@ -0,0 +1,7 @@
+export class PepPaddingSettings {
+    constructor(isUniform = true, paddingValue = '0') {
+        this.IsUniform = isUniform;
+        this.PaddingValue = paddingValue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFkZGluZy1zZXR0aW5ncy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3BhZGRpbmctc2V0dGluZ3MvcGFkZGluZy1zZXR0aW5ncy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sa0JBQWtCO0lBSTNCLFlBQVksU0FBUyxHQUFHLElBQUksRUFBRSxZQUFZLEdBQUcsR0FBRztRQUM1QyxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQixJQUFJLENBQUMsWUFBWSxHQUFHLFlBQVksQ0FBQztJQUNyQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQZXBTaXplVHlwZSB9IGZyb20gXCJAcGVwcGVyaS1hZGRvbnMvbmd4LWxpYlwiO1xyXG5cclxuZXhwb3J0IGNsYXNzIFBlcFBhZGRpbmdTZXR0aW5ncyB7XHJcbiAgICBJc1VuaWZvcm06IGJvb2xlYW47XHJcbiAgICBQYWRkaW5nVmFsdWU6IHN0cmluZztcclxuXHJcbiAgICBjb25zdHJ1Y3Rvcihpc1VuaWZvcm0gPSB0cnVlLCBwYWRkaW5nVmFsdWUgPSAnMCcpe1xyXG4gICAgICAgIHRoaXMuSXNVbmlmb3JtID0gaXNVbmlmb3JtO1xyXG4gICAgICAgIHRoaXMuUGFkZGluZ1ZhbHVlID0gcGFkZGluZ1ZhbHVlO1xyXG4gICAgfVxyXG59Il19

package/esm2020/padding-settings/padding-settings.module.mjs

@@ -0,0 +1,46 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PaddingSettingsComponent } from './padding-settings.component';
+import { PepNgxLibModule } from '@pepperi-addons/ngx-lib';
+import { PepCheckboxModule } from '@pepperi-addons/ngx-lib/checkbox';
+import { PepTextboxModule } from '@pepperi-addons/ngx-lib/textbox';
+import { PepFieldTitleModule } from '@pepperi-addons/ngx-lib/field-title';
+import { PepGroupButtonsModule } from '@pepperi-addons/ngx-lib/group-buttons';
+import { PepSliderModule } from '@pepperi-addons/ngx-lib/slider';
+import * as i0 from "@angular/core";
+export class PepPaddingSettingsModule {
+}
+PepPaddingSettingsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepPaddingSettingsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PepPaddingSettingsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: PepPaddingSettingsModule, declarations: [PaddingSettingsComponent], imports: [CommonModule,
+        PepNgxLibModule,
+        PepCheckboxModule,
+        PepTextboxModule,
+        PepFieldTitleModule,
+        PepGroupButtonsModule,
+        PepSliderModule], exports: [PaddingSettingsComponent] });
+PepPaddingSettingsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepPaddingSettingsModule, imports: [CommonModule,
+        PepNgxLibModule,
+        PepCheckboxModule,
+        PepTextboxModule,
+        PepFieldTitleModule,
+        PepGroupButtonsModule,
+        PepSliderModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PepPaddingSettingsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        PaddingSettingsComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        PepNgxLibModule,
+                        PepCheckboxModule,
+                        PepTextboxModule,
+                        PepFieldTitleModule,
+                        PepGroupButtonsModule,
+                        PepSliderModule
+                    ],
+                    exports: [PaddingSettingsComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFkZGluZy1zZXR0aW5ncy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9wYWRkaW5nLXNldHRpbmdzL3BhZGRpbmctc2V0dGluZ3MubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNyRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUMxRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7O0FBaUJqRSxNQUFNLE9BQU8sd0JBQXdCOztzSEFBeEIsd0JBQXdCO3VIQUF4Qix3QkFBd0IsaUJBYjdCLHdCQUF3QixhQUd4QixZQUFZO1FBQ1osZUFBZTtRQUNmLGlCQUFpQjtRQUNqQixnQkFBZ0I7UUFDaEIsbUJBQW1CO1FBQ25CLHFCQUFxQjtRQUNyQixlQUFlLGFBRVQsd0JBQXdCO3VIQUV6Qix3QkFBd0IsWUFWN0IsWUFBWTtRQUNaLGVBQWU7UUFDZixpQkFBaUI7UUFDakIsZ0JBQWdCO1FBQ2hCLG1CQUFtQjtRQUNuQixxQkFBcUI7UUFDckIsZUFBZTs0RkFJVix3QkFBd0I7a0JBZnBDLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFO3dCQUNWLHdCQUF3QjtxQkFDM0I7b0JBQ0QsT0FBTyxFQUFFO3dCQUNMLFlBQVk7d0JBQ1osZUFBZTt3QkFDZixpQkFBaUI7d0JBQ2pCLGdCQUFnQjt3QkFDaEIsbUJBQW1CO3dCQUNuQixxQkFBcUI7d0JBQ3JCLGVBQWU7cUJBQ2xCO29CQUNELE9BQU8sRUFBRSxDQUFDLHdCQUF3QixDQUFDO2lCQUN0QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgUGFkZGluZ1NldHRpbmdzQ29tcG9uZW50IH0gZnJvbSAnLi9wYWRkaW5nLXNldHRpbmdzLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQZXBOZ3hMaWJNb2R1bGUgfSBmcm9tICdAcGVwcGVyaS1hZGRvbnMvbmd4LWxpYic7XG5pbXBvcnQgeyBQZXBDaGVja2JveE1vZHVsZSB9IGZyb20gJ0BwZXBwZXJpLWFkZG9ucy9uZ3gtbGliL2NoZWNrYm94JztcbmltcG9ydCB7IFBlcFRleHRib3hNb2R1bGUgfSBmcm9tICdAcGVwcGVyaS1hZGRvbnMvbmd4LWxpYi90ZXh0Ym94JztcbmltcG9ydCB7IFBlcEZpZWxkVGl0bGVNb2R1bGUgfSBmcm9tICdAcGVwcGVyaS1hZGRvbnMvbmd4LWxpYi9maWVsZC10aXRsZSc7XG5pbXBvcnQgeyBQZXBHcm91cEJ1dHRvbnNNb2R1bGUgfSBmcm9tICdAcGVwcGVyaS1hZGRvbnMvbmd4LWxpYi9ncm91cC1idXR0b25zJztcbmltcG9ydCB7IFBlcFNsaWRlck1vZHVsZSB9IGZyb20gJ0BwZXBwZXJpLWFkZG9ucy9uZ3gtbGliL3NsaWRlcic7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbXG4gICAgICAgIFBhZGRpbmdTZXR0aW5nc0NvbXBvbmVudFxuICAgIF0sXG4gICAgaW1wb3J0czogW1xuICAgICAgICBDb21tb25Nb2R1bGUsXG4gICAgICAgIFBlcE5neExpYk1vZHVsZSxcbiAgICAgICAgUGVwQ2hlY2tib3hNb2R1bGUsXG4gICAgICAgIFBlcFRleHRib3hNb2R1bGUsXG4gICAgICAgIFBlcEZpZWxkVGl0bGVNb2R1bGUsXG4gICAgICAgIFBlcEdyb3VwQnV0dG9uc01vZHVsZSxcbiAgICAgICAgUGVwU2xpZGVyTW9kdWxlXG4gICAgXSxcbiAgICBleHBvcnRzOiBbUGFkZGluZ1NldHRpbmdzQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgUGVwUGFkZGluZ1NldHRpbmdzTW9kdWxlIHsgfVxuIl19

package/esm2020/padding-settings/pepperi-addons-ngx-composite-lib-padding-settings.mjs

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

package/esm2020/padding-settings/public-api.mjs

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of ngx-composite-lib/padding-settings
+ */
+export * from './padding-settings.module';
+export * from './padding-settings.component';
+export * from './padding-settings.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3BhZGRpbmctc2V0dGluZ3MvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY29tcG9zaXRlLWxpYi9wYWRkaW5nLXNldHRpbmdzXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vcGFkZGluZy1zZXR0aW5ncy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wYWRkaW5nLXNldHRpbmdzLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BhZGRpbmctc2V0dGluZ3MubW9kZWwnO1xuIl19