npm - nuxeo-development-framework - Versions diffs - 3.1.6 → 3.1.8 - Mend

nuxeo-development-framework 3.1.6 → 3.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1229) hide show

package/esm2015/lib/components/dynamic-form/components/dynamic-form-field/dynamic-form-field.component.js ADDED Viewed

@@ -0,0 +1,85 @@
+import { ChangeDetectionStrategy, Component, Input, Optional, Self } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/forms";
+import * as i3 from "angular-formio";
+export class DynamicFormFieldComponent {
+    constructor(translate, control) {
+        this.translate = translate;
+        this.control = control;
+        this.disabled = false;
+        this.onDestroy$ = new Subject();
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.Validator = (control) => {
+            if (!this.value.isValid) {
+                return { formValidator: true };
+            }
+            return null;
+        };
+        this.control.valueAccessor = this;
+    }
+    get invalid() {
+        return this.control ? this.control.invalid : false;
+    }
+    get showError() {
+        if (!this.control) {
+            return false;
+        }
+        const { dirty, touched } = this.control;
+        return this.invalid ? (dirty || touched) : false;
+    }
+    isRequired() {
+        if (!this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return (validator && validator.required);
+    }
+    writeValue(value) {
+        this.value = value;
+    }
+    ngOnInit() {
+        this.control.control.setValidators([this.Validator]);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    onChanged(value) {
+        console.log(value);
+        this.value = value;
+        this.onChange(value);
+        this.onTouched();
+    }
+}
+DynamicFormFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormFieldComponent, deps: [{ token: i1.TranslateService }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: DynamicFormFieldComponent, selector: "cts-dynamic-form-field", inputs: { disabled: "disabled", field: "field" }, ngImport: i0, template: "<formio [form]=\"field\" (change)=\"onChanged($event)\"></formio>\r\n", styles: [""], components: [{ type: i3.FormioComponent, selector: "formio" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-dynamic-form-field',
+                    templateUrl: './dynamic-form-field.component.html',
+                    styleUrls: ['./dynamic-form-field.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/dynamic-form/components/dynamic-form-hijri-dateitem/dynamic-form-hijri-dateitem.component.js ADDED Viewed

@@ -0,0 +1,139 @@
+import { Component, ViewChild, Optional, Self, Input, ViewEncapsulation, EventEmitter, Output, } from '@angular/core';
+import * as momentjs from 'moment';
+import * as moment_ from 'moment-hijri';
+import { DateType } from '../../../hijri-gregorian-datepicker/utils/consts';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../hijri-gregorian-datepicker/services/date-formatter.service";
+import * as i2 from "@angular/forms";
+import * as i3 from "../../../hijri-gregorian-datepicker/hijri-gregorian-datepicker/hijri-gregorian-datepicker.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-translate/core";
+const moment = momentjs;
+const momentHijri = moment_;
+/**
+ * A Hijri and gregorian datepicker
+ *  that can be used inside reactive or template driven forms
+ * @title
+ * Hijri Gregorian Datepicker
+ *
+ * @example
+ * <cts-dynamic-form-hijri-dateitem
+ *     formControlName="controlName"
+ *     label="PATH.TO.LABEL.TRANSLATION"
+ *     [placeholder]="'PATH.TO.PLACEHOLDER.STRING'"
+ *     [minGreg]="maxDate"
+ *   >
+ *   </cts-dynamic-form-hijri-dateitem>
+ */
+export class DynamicFormHijriDateitemComponent {
+    constructor(dateFormatterService, control) {
+        this.dateFormatterService = dateFormatterService;
+        this.control = control;
+        /** list inputs vertically (for range only) */
+        this.vertical = false;
+        /** Sets picker to readonly mode */
+        this.isReadOnly = true;
+        /** Emitted when the value changes */
+        this.valueChanged = new EventEmitter();
+        this.selectedDateType = DateType.Gregorian;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.control.valueAccessor = this;
+        if (!this.range) {
+            // this.date = this.dateFormatterService.GetTodayGregorian();
+        }
+    }
+    writeValue(obj) {
+        if (obj) {
+            if (!this.range) {
+                this.date = this.dateFormatterService.ToGregorianDateStruct(obj, '');
+            }
+            else if (obj.from && obj.to) {
+                this.date = {
+                    from: this.dateFormatterService.ToGregorianDateStruct(obj.from, ''),
+                    to: this.dateFormatterService.ToGregorianDateStruct(obj.to, '')
+                };
+            }
+        }
+        else {
+            this.date = null; // to reset ui too
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) { }
+    ngOnInit() {
+        this.placeHolder = (this.placeholder) ? this.placeholder : 'datePlaceHolder';
+    }
+    ngAfterViewInit() {
+        //Called after ngAfterContentInit when the component's view has been initialized. Applies to components only.
+        //Add 'implements AfterViewInit' to the class.
+        //  console.log('startDatePicker', this.startDatePicker);
+    }
+    removelable() { }
+    setValue(event) {
+        this.dateString = this.startDatePicker.getSelectedDate();
+        if (this.dateString !== 'Invalid date') {
+            this.onChange(this.dateString);
+            this.valueChanged.emit(this.dateString);
+        }
+        else {
+            // set value to null when clear date
+            this.onChange(null),
+                this.valueChanged.emit(null);
+        }
+    }
+    isRequired() {
+        var _a;
+        if (!((_a = this.control) === null || _a === void 0 ? void 0 : _a.control) || !this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return validator && validator.required;
+    }
+}
+DynamicFormHijriDateitemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormHijriDateitemComponent, deps: [{ token: i1.DateFormatterService }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormHijriDateitemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: DynamicFormHijriDateitemComponent, selector: "cts-dynamic-form-hijri-dateitem", inputs: { minHijri: "minHijri", maxHijri: "maxHijri", minGreg: "minGreg", maxGreg: "maxGreg", label: "label", isDisabled: "isDisabled", range: "range", vertical: "vertical", isReadOnly: "isReadOnly", placeholder: "placeholder" }, outputs: { valueChanged: "valueChanged" }, viewQueries: [{ propertyName: "startDatePicker", first: true, predicate: ["datePicker"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"label\">\r\n  <div>\r\n    <label class=\"hijri-date-lable\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n    >\r\n  </div>\r\n</ng-container>\r\n<div class=\"hijri-date-container\">\r\n  <hijri-gregorian-datepicker\r\n    [placeHolder]=\"placeHolder | translate\"\r\n    [(selectedDate)]=\"date\"\r\n    [isRequired]=\"true\"\r\n    [GregLabel]=\"'gregorian' | translate\"\r\n    [hijriLabel]=\"'hijri' |translate\"\r\n    [selectedDateType]=\"selectedDateType\"\r\n    [disabled]=\"isDisabled\"\r\n    [readonly]=\"isReadOnly\"\r\n    [minHijri]=\"minHijri\"\r\n    [maxHijri]=\"maxHijri\"\r\n    [minGreg]=\"minGreg\"\r\n    [maxGreg]=\"maxGreg\"\r\n    [range]=\"range\"\r\n    [vertical]=\"vertical\"\r\n    (selectedDateChange)=\"setValue($event)\"\r\n    #datePicker\r\n  >\r\n  </hijri-gregorian-datepicker>\r\n</div>\r\n", styles: [".bi{margin:0!important}.memo-sorting-wrapper{width:265px;margin:0 10px;height:100%;display:flex}.memo-sorting-wrapper .sorting-direction{width:65px;height:40px;background-color:#465573;color:#fff;font-size:20px;display:flex;justify-content:center;align-items:center;cursor:pointer}.memo-sorting-wrapper .memo-sorting-trigger{width:calc(100% - 65px);height:100%;background-color:transparent;border:1px solid lightgrey;display:flex;justify-content:space-between;align-items:center;padding:0 15px;font-size:14px}.memo-sorting-wrapper .memo-sorting-trigger i{font-size:16px;color:gray}.memo-sorting-menu{width:200px}.my-button{border:1px solid #465573;color:#465573;border-radius:5px;background-color:transparent;font-weight:bold;min-width:80px;height:40px}.my-button.reset{border:none}.my-button:hover{color:#fff;background-color:#465573}.my-button:hover.reset{color:#465573;border:1px solid #465573;background-color:#fff}.app-property-value .app-input-wrapper label{color:#646f85;font-size:13px;margin-bottom:5px}.app-property-value .app-input-wrapper label .text-danger{font-size:16px;line-height:14px;margin:0 5px!important}.app-property-value .app-input-wrapper .form-control{border:1px solid #ccc;border-radius:5px;background-color:#8f98aa1a;height:40px}.app-property-value .app-input-wrapper .form-control:disabled{background-color:#e9ecef!important}.app-property-value .app-input-wrapper .form-control:focus{border:1px solid #1a96c6;box-shadow:0 0 4px #79c3c26b!important}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers{list-style:none;padding:0;margin:0;font-size:14px}.app-property-value .app-input-wrapper .app-textitem-editable-error .error-containers .error{margin-top:5px}.autocomplete-container .input-container input:focus,hijri-gregorian-datepicker .form-group .input-group .form-control:focus,.ng-select.ng-select-focused .ng-select-container{border:1px solid #1a96c6!important;box-shadow:0 0 4px #79c3c26b!important}input::placeholder{font-size:12px}.form-control:focus{box-shadow:none!important}.mat-stepper-horizontal{margin-top:-25px}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header.cdk-program-focused{background-color:transparent}.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-icon-selected{background-color:transparent;color:#fff;background-image:linear-gradient(to right,#0dbab5,#1a96c6)}@media only screen and (max-width: 576px){.mat-stepper-horizontal .mat-horizontal-stepper-header-container .mat-step-header .mat-step-label .mat-step-text-label{white-space:pre-wrap;overflow:visible}}.mat-stepper-horizontal .mat-horizontal-content-container{overflow:visible}@media only screen and (max-width: 768px){.mat-stepper-horizontal .mat-horizontal-content-container{padding:0 0 24px}}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:after,.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:before{display:none}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:first-child:before{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);left:0}.mat-stepper-horizontal.rtl .mat-horizontal-stepper-header:last-child:after{border-top-width:1px;border-top-style:solid;content:\"\";display:inline-block;height:0;position:absolute;width:calc(50% - 20px);right:0}.form-wrapper{padding:30px 15px;border:1px solid #dde0e2}.form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.form-wrapper .buttons-wrapper button:hover{opacity:.7}.form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.form-wrapper .upload-wrapper button span{margin:0 10px}.renameFileComponent .form-wrapper{padding:30px 15px;border:none!important}.renameFileComponent .form-wrapper .buttons-wrapper{display:flex;justify-content:space-between}.renameFileComponent .form-wrapper .buttons-wrapper .action-buttons-wrapper{display:flex}.renameFileComponent .form-wrapper .buttons-wrapper button{background-image:linear-gradient(to right,#0dbab5,#1a96c6);height:40px;color:#fff;border:none;width:125px;margin-top:20px;border-radius:5px}.renameFileComponent .form-wrapper .buttons-wrapper button:disabled{opacity:.4;cursor:not-allowed}.renameFileComponent .form-wrapper .buttons-wrapper button:hover{opacity:.7}.renameFileComponent .form-wrapper .upload-wrapper{display:flex;flex-direction:column;justify-content:flex-end}.renameFileComponent .form-wrapper .upload-wrapper label{color:#8f98aa;font-size:14px}.renameFileComponent .form-wrapper .upload-wrapper button{padding:10px;border:1px solid lightgray}.renameFileComponent .form-wrapper .upload-wrapper button span{margin:0 10px}.my-dynamic-viewer{display:flex;align-items:center;font-size:12px;min-height:30px}.my-dynamic-viewer .my-label{font-size:12px;font-weight:500;width:150px;word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-label{width:50%}}.my-dynamic-viewer .my-value{width:calc(100% - 150px);word-break:break-word}@media (max-width: 992px){.my-dynamic-viewer .my-value{width:50%}}.my-dynamic-viewer .direction-img{font-size:14px}.my-dynamic-viewer .direction-img .incoming{display:none}.my-dynamic-viewer .direction-img .outgoing{display:none}.my-dynamic-viewer .direction-img .internal{display:none}.my-dynamic-viewer.draft .my-value{color:#596973}.my-dynamic-viewer.inProgress .my-value{color:#3c3cf0}.my-dynamic-viewer.registered .my-value{color:#4f008c}.my-dynamic-viewer.archived .my-value{color:#fbb62c}.my-dynamic-viewer.closed .my-value{color:#00dca5}.my-dynamic-viewer.approved .my-value{color:#06a57e}.my-dynamic-viewer.assigned .my-value{color:#fd6670}.my-dynamic-viewer.sent .my-value{color:#3c3cf0}.my-dynamic-viewer.published .my-value{color:#00dca5}.my-dynamic-viewer.Outgoing .my-value{display:flex}.my-dynamic-viewer.Outgoing .my-value .direction-img .outgoing{color:#fbb62c;margin:1px 5px;display:flex}.my-dynamic-viewer.Outgoing .my-value .text{margin:0 5px}.my-dynamic-viewer.Internal .my-value{display:flex}.my-dynamic-viewer.Internal .my-value .direction-img .internal{color:#3c3cf0;margin:1px 5px;display:flex}.my-dynamic-viewer.Internal .my-value .text{margin:0 5px}.my-dynamic-viewer.Incoming .my-value{display:flex}.my-dynamic-viewer.Incoming .my-value .direction-img .incoming{color:#00dca5;display:flex}.my-dynamic-viewer.Incoming .my-value .text{margin:-3px 5px 0}.my-dynamic-viewer.vertical{display:block}.my-dynamic-viewer.vertical .my-label{width:auto}.my-dynamic-viewer.vertical .my-value{width:auto}.my-dynamic-viewer.with-out-label{width:100%!important}.hijri-date-lable{color:#646f85;font-size:13px;margin-bottom:5px}hijri-gregorian-datepicker .form-group .requiredInput{display:none}hijri-gregorian-datepicker .form-group .input-group{display:flex;flex-wrap:nowrap;align-items:stretch;width:100%}hijri-gregorian-datepicker .form-group .input-group hijri-date-picker{display:block}hijri-gregorian-datepicker .form-group .input-group .form-control{border:1px solid #ccc;border-start-start-radius:5px;border-end-start-radius:5px;border-start-end-radius:0;border-end-end-radius:0;background-color:#8f98aa1a;height:40px}hijri-gregorian-datepicker .form-group .input-group .input-group-append{margin:0}hijri-gregorian-datepicker .form-group .input-group .input-group-append .btn{border-start-end-radius:5px!important;border-end-end-radius:5px!important;border-start-start-radius:0!important;border-end-start-radius:0!important;display:block;margin:0;border:none;color:#fff;background-color:#b4bac6}hijri-gregorian-datepicker .form-group .input-group .input-group-append .btn:hover{background-color:#8f98aa}hijri-gregorian-datepicker .form-group .input-group .input-group-append .active{display:none}\n"], components: [{ type: i3.HijriGregorianDatepickerComponent, selector: "hijri-gregorian-datepicker", inputs: ["selectedDateType", "selectedDate", "label", "showLabel", "readonly", "isRequired", "disabled", "disabledbtn", "minHijri", "maxHijri", "minGreg", "maxGreg", "hijriLabel", "GregLabel", "placeHolder", "range", "vertical"], outputs: ["selectedDateChange"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i5.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormHijriDateitemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-dynamic-form-hijri-dateitem',
+                    templateUrl: './dynamic-form-hijri-dateitem.component.html',
+                    styleUrls: ['./dynamic-form-hijri-dateitem.component.scss'],
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DateFormatterService }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { minHijri: [{
+                type: Input
+            }], maxHijri: [{
+                type: Input
+            }], minGreg: [{
+                type: Input
+            }], maxGreg: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], range: [{
+                type: Input
+            }], vertical: [{
+                type: Input
+            }], isReadOnly: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], valueChanged: [{
+                type: Output
+            }], startDatePicker: [{
+                type: ViewChild,
+                args: ['datePicker']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-hijri-dateitem.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-hijri-dateitem/dynamic-form-hijri-dateitem.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-hijri-dateitem/dynamic-form-hijri-dateitem.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  ViewChild,\r\n  OnInit,\r\n  Optional,\r\n  Self,\r\n  Input,\r\n  ViewEncapsulation,\r\n  EventEmitter,\r\n  Output,\r\n} from '@angular/core';\r\nimport { NgbDate, NgbDateStruct } from '@ng-bootstrap/ng-bootstrap';\r\n\r\nimport * as momentjs from 'moment';\r\nconst moment = momentjs;\r\n\r\nimport * as moment_ from 'moment-hijri';\r\nimport {\r\n  AbstractControl,\r\n  ControlValueAccessor,\r\n  NgControl,\r\n} from '@angular/forms';\r\nimport { DateType } from '../../../hijri-gregorian-datepicker/utils/consts';\r\nimport { DateFormatterService } from '../../../hijri-gregorian-datepicker/services/date-formatter.service';\r\nconst momentHijri = moment_;\r\n/**\r\n * A Hijri and gregorian datepicker\r\n *  that can be used inside reactive or template driven forms\r\n * @title\r\n * Hijri Gregorian Datepicker\r\n *\r\n * @example\r\n * <cts-dynamic-form-hijri-dateitem\r\n *     formControlName=\"controlName\"\r\n *     label=\"PATH.TO.LABEL.TRANSLATION\"\r\n *     [placeholder]=\"'PATH.TO.PLACEHOLDER.STRING'\"\r\n *     [minGreg]=\"maxDate\"\r\n *   >\r\n *   </cts-dynamic-form-hijri-dateitem>\r\n */\r\n@Component({\r\n  selector: 'cts-dynamic-form-hijri-dateitem',\r\n  templateUrl: './dynamic-form-hijri-dateitem.component.html',\r\n  styleUrls: ['./dynamic-form-hijri-dateitem.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class DynamicFormHijriDateitemComponent\r\n  implements OnInit, ControlValueAccessor {\r\n  /** Minimum Hijri Date */\r\n  @Input()\r\n  minHijri: NgbDate;\r\n  /** Max Hijri Date */\r\n  @Input()\r\n  maxHijri: NgbDate;\r\n  /** Minimum Gregorian Date */\r\n  @Input()\r\n  minGreg: NgbDate;\r\n  /** Max Gregorian Date */\r\n  @Input()\r\n  maxGreg: NgbDate;\r\n  /** Field Label */\r\n  @Input()\r\n  label;\r\n  /** Is input disabled */\r\n  @Input()\r\n  isDisabled: boolean;\r\n  /** is input a range picker */\r\n  @Input()\r\n  range: boolean;\r\n  /** list inputs vertically (for range only) */\r\n  @Input()\r\n  vertical = false;\r\n  /** Sets picker to readonly mode */\r\n  @Input()\r\n  isReadOnly: boolean = true;\r\n  @Input()\r\n  placeholder: string;\r\n  /** Emitted when the value changes */\r\n  @Output()\r\n  valueChanged: EventEmitter<any> = new EventEmitter();\r\n  date: any;\r\n  dateString: string;\r\n  placeHolder: string;\r\n  selectedDateType = DateType.Gregorian;\r\n  onChange: any = () => { };\r\n  onTouched: any = () => { };\r\n\r\n  @ViewChild('datePicker') startDatePicker: any;\r\n\r\n  constructor(\r\n    private dateFormatterService: DateFormatterService,\r\n    @Self() @Optional() private control: NgControl\r\n  ) {\r\n    this.control.valueAccessor = this;\r\n    if (!this.range) {\r\n      // this.date = this.dateFormatterService.GetTodayGregorian();\r\n    }\r\n  }\r\n  writeValue(obj: any): void {\r\n    if (obj) {\r\n      if (!this.range) {\r\n        this.date = this.dateFormatterService.ToGregorianDateStruct(obj, '');\r\n      } else if (obj.from && obj.to) {\r\n        this.date = {\r\n          from: this.dateFormatterService.ToGregorianDateStruct(obj.from, ''),\r\n          to: this.dateFormatterService.ToGregorianDateStruct(obj.to, '')\r\n\r\n        }\r\n      }\r\n    } else {\r\n      this.date = null; // to reset ui too\r\n    }\r\n  }\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void { }\r\n\r\n  ngOnInit(): void {\r\n    this.placeHolder = (this.placeholder) ? this.placeholder : 'datePlaceHolder';\r\n  }\r\n  ngAfterViewInit(): void {\r\n    //Called after ngAfterContentInit when the component's view has been initialized. Applies to components only.\r\n    //Add 'implements AfterViewInit' to the class.\r\n    //  console.log('startDatePicker', this.startDatePicker);\r\n  }\r\n\r\n  removelable() { }\r\n\r\n  setValue(event) {\r\n    this.dateString = this.startDatePicker.getSelectedDate();\r\n    if (this.dateString !== 'Invalid date') {\r\n      this.onChange(this.dateString);\r\n      this.valueChanged.emit(this.dateString);\r\n    }else{\r\n      // set value to null when clear date \r\n      this.onChange(null),\r\n      this.valueChanged.emit(null)\r\n    }\r\n  }\r\n  isRequired() {\r\n    if (!this.control?.control || !this.control.control.validator) {\r\n      return false;\r\n    }\r\n\r\n    const validator = this.control.control.validator({} as AbstractControl);\r\n    return validator && validator.required;\r\n  }\r\n}\r\n","<ng-container *ngIf=\"label\">\r\n  <div>\r\n    <label class=\"hijri-date-lable\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n    >\r\n  </div>\r\n</ng-container>\r\n<div class=\"hijri-date-container\">\r\n  <hijri-gregorian-datepicker\r\n    [placeHolder]=\"placeHolder | translate\"\r\n    [(selectedDate)]=\"date\"\r\n    [isRequired]=\"true\"\r\n    [GregLabel]=\"'gregorian' | translate\"\r\n    [hijriLabel]=\"'hijri' |translate\"\r\n    [selectedDateType]=\"selectedDateType\"\r\n    [disabled]=\"isDisabled\"\r\n    [readonly]=\"isReadOnly\"\r\n    [minHijri]=\"minHijri\"\r\n    [maxHijri]=\"maxHijri\"\r\n    [minGreg]=\"minGreg\"\r\n    [maxGreg]=\"maxGreg\"\r\n    [range]=\"range\"\r\n    [vertical]=\"vertical\"\r\n    (selectedDateChange)=\"setValue($event)\"\r\n    #datePicker\r\n  >\r\n  </hijri-gregorian-datepicker>\r\n</div>\r\n"]}

package/esm2015/lib/components/dynamic-form/components/dynamic-form-item-dispatcher/dynamic-form-item-dispatcher.component.js ADDED Viewed

@@ -0,0 +1,81 @@
+import { Component, Input, ViewChild, ViewEncapsulation } from '@angular/core';
+import { DynamicFormContentProxyDirective } from '../../directives/dynamic-form-content-proxy.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/card-item-types.service";
+import * as i2 from "../../directives/dynamic-form-content-proxy.directive";
+/** @ignore */
+export class DynamicFormItemDispatcherComponent {
+    constructor(cardItemTypeService, resolver) {
+        this.cardItemTypeService = cardItemTypeService;
+        this.resolver = resolver;
+        this.displayEmpty = true;
+        this.displayNoneOption = true;
+        this.displayClearAction = true;
+        this.loaded = false;
+        this.componentReference = null;
+        const dynamicLifeCycleMethods = [
+            'ngOnInit',
+            'ngDoCheck',
+            'ngAfterContentInit',
+            'ngAfterContentChecked',
+            'ngAfterViewInit',
+            'ngAfterViewChecked',
+            'ngOnDestroy'
+        ];
+        dynamicLifeCycleMethods.forEach(method => {
+            this[method] = this.proxy.bind(this, method);
+        });
+    }
+    ngOnChanges(changes) {
+        if (!this.loaded) {
+            this.loadComponent();
+            this.loaded = true;
+        }
+        Object.keys(changes)
+            .map(changeName => [changeName, changes[changeName]])
+            .forEach(([inputParamName, simpleChange]) => {
+            this.componentReference.instance[inputParamName] =
+                simpleChange.currentValue;
+        });
+        this.proxy('ngOnChanges', changes);
+    }
+    loadComponent() {
+        const factoryClass = this.cardItemTypeService.resolveComponentType(this.property);
+        const factory = this.resolver.resolveComponentFactory(factoryClass);
+        this.componentReference = this.content.viewContainerRef.createComponent(factory);
+        this.componentReference.instance.editable = this.editable;
+        this.componentReference.instance.property = this.property;
+        this.componentReference.instance.displayEmpty = this.displayEmpty;
+        this.componentReference.instance.displayNoneOption = this.displayNoneOption;
+        this.componentReference.instance.displayClearAction = this.displayClearAction;
+    }
+    proxy(methodName, ...args) {
+        if (this.componentReference.instance[methodName]) {
+            this.componentReference.instance[methodName].apply(this.componentReference.instance, args);
+        }
+    }
+}
+DynamicFormItemDispatcherComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormItemDispatcherComponent, deps: [{ token: i1.CardItemTypeService }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormItemDispatcherComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: DynamicFormItemDispatcherComponent, selector: "app-dynamic-form-item-dispatcher", inputs: { property: "property", editable: "editable", displayEmpty: "displayEmpty", displayNoneOption: "displayNoneOption", displayClearAction: "displayClearAction" }, viewQueries: [{ propertyName: "content", first: true, predicate: DynamicFormContentProxyDirective, descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<ng-template appDynamicFormContentProxy></ng-template>', isInline: true, directives: [{ type: i2.DynamicFormContentProxyDirective, selector: "[appDynamicFormContentProxy]" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormItemDispatcherComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-dynamic-form-item-dispatcher',
+                    template: '<ng-template appDynamicFormContentProxy></ng-template>',
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CardItemTypeService }, { type: i0.ComponentFactoryResolver }]; }, propDecorators: { property: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], displayEmpty: [{
+                type: Input
+            }], displayNoneOption: [{
+                type: Input
+            }], displayClearAction: [{
+                type: Input
+            }], content: [{
+                type: ViewChild,
+                args: [DynamicFormContentProxyDirective, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/dynamic-form/components/dynamic-form-mapitem/dynamic-form-mapitem.component.js ADDED Viewed

@@ -0,0 +1,36 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/dynamic-form-update.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+/** @ignore */
+export class DynamicFormMapItemComponent {
+    constructor(dynamicFormUpdateService) {
+        this.dynamicFormUpdateService = dynamicFormUpdateService;
+        this.displayEmpty = true;
+    }
+    showProperty() {
+        return this.displayEmpty || !this.property.isEmpty();
+    }
+    isClickable() {
+        return this.property.clickable;
+    }
+    clicked() {
+        this.dynamicFormUpdateService.clicked(this.property);
+    }
+}
+DynamicFormMapItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormMapItemComponent, deps: [{ token: i1.DynamicFormUpdateService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormMapItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: DynamicFormMapItemComponent, selector: "app-dynamic-form-mapitem", inputs: { property: "property", displayEmpty: "displayEmpty" }, ngImport: i0, template: "<div\r\n  [attr.data-automation-id]=\"'card-mapitem-label-' + property.key\"\r\n  class=\"app-property-label\"\r\n  *ngIf=\"showProperty()\"\r\n>\r\n  {{ property.label | translate }}\r\n</div>\r\n<div class=\"app-property-value\">\r\n  <div>\r\n    <span\r\n      *ngIf=\"!isClickable(); else elseBlock\"\r\n      [attr.data-automation-id]=\"'card-mapitem-value-' + property.key\"\r\n    >\r\n      <span *ngIf=\"showProperty()\">{{ property.displayValue }}</span>\r\n    </span>\r\n    <ng-template #elseBlock>\r\n      <span\r\n        class=\"app-mapitem-clickable-value\"\r\n        (click)=\"clicked()\"\r\n        [attr.data-automation-id]=\"'card-mapitem-value-' + property.key\"\r\n      >\r\n        <span *ngIf=\"showProperty(); else elseEmptyValueBlock\">{{\r\n          property.displayValue\r\n        }}</span>\r\n      </span>\r\n    </ng-template>\r\n  </div>\r\n  <ng-template #elseEmptyValueBlock>\r\n    {{ property.default | translate }}\r\n  </ng-template>\r\n</div>\r\n", styles: [".app-mapitem-clickable-value{cursor:pointer!important}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i3.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormMapItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-dynamic-form-mapitem',
+                    templateUrl: './dynamic-form-mapitem.component.html',
+                    styleUrls: ['./dynamic-form-mapitem.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormUpdateService }]; }, propDecorators: { property: [{
+                type: Input
+            }], displayEmpty: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/dynamic-form/components/dynamic-form-options/dynamic-form-options.component.js ADDED Viewed

@@ -0,0 +1,106 @@
+import { Component, Input, Optional, Self, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/radio";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+/**
+ * Options group input that can be used inside reactive or template driven forms
+ * @title
+ * Options Group
+ * @example
+ *   <cts-dynamic-form-options
+ *    [label]="'Choose an item'"
+ *    [data]="arrayOfItems"
+ *    [bindLabel]="'name'"
+ *    [bindValue]="'id'"
+ *    [multiple]="false"
+ *    formControlName="option">
+ * </cts-dynamic-form-options>
+ */
+export class DynamicFormOptionsComponent {
+    constructor(control) {
+        this.control = control;
+        /** can select multiple (checkboxes) or (radios) */
+        this.multiple = false;
+        // @Output() onSelectItems = new EventEmitter();
+        this.selection = [];
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.control.valueAccessor = this;
+    }
+    ngOnInit() { }
+    writeValue(value) {
+        if (value && this.multiple) {
+            this.selection = [...value];
+        }
+        if (value && !this.multiple) {
+            this.selectedItem = value;
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        throw new Error('Method not implemented.');
+    }
+    isRequired() {
+        if (!this.control || !this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return validator && validator.required;
+    }
+    //multiple functions
+    emitSelection(value, isChecked) {
+        if (isChecked) {
+            this.selection.push(value);
+        }
+        else {
+            this.selection = this.selection.filter((item) => {
+                return typeof value === 'object'
+                    ? JSON.stringify(value) != JSON.stringify(item)
+                    : value != item;
+            });
+        }
+        this.onChange(this.selection);
+    }
+    containsValue(value, list) {
+        return typeof value === 'object'
+            ? list.some((elem) => JSON.stringify(elem) === JSON.stringify(value))
+            : list.includes(value);
+    }
+    // !multiple functions
+    onSelectedItemChanged(event) {
+        this.onChange(this.selectedItem);
+    }
+}
+DynamicFormOptionsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormOptionsComponent, deps: [{ token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormOptionsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.4", type: DynamicFormOptionsComponent, selector: "cts-dynamic-form-options", inputs: { label: "label", data: "data", bindLabel: "bindLabel", bindValue: "bindValue", multiple: "multiple" }, ngImport: i0, template: "<!-- template for viewing single select selected value -->\r\n<ng-container *ngIf=\"multiple\">\r\n  <ng-container *ngIf=\"label\">\r\n    <div>\r\n      <label class=\"radio-label\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n      >\r\n    </div>\r\n  </ng-container>\r\n  <div class=\"option-wrapper\" *ngFor=\"let item of data ; let i = index\">\r\n    <span>\r\n      <input\r\n        id=\"item-{{ i }}\"\r\n        type=\"checkbox\"\r\n        (change)=\"\r\n          emitSelection(\r\n            bindValue ? item[bindValue] : item,\r\n            $event.target.checked\r\n          )\r\n        \"\r\n        [checked]=\"containsValue(bindValue ? item[bindValue] : item, selection)\"\r\n      />\r\n    </span>\r\n    <span class=\"label-wrapper\">\r\n      {{ (bindLabel ? item[bindLabel] : item) | translate }}\r\n    </span>\r\n  </div>\r\n</ng-container>\r\n<ng-container *ngIf=\"!multiple\">\r\n  <ng-container *ngIf=\"label\">\r\n    <div>\r\n      <label class=\"radio-label\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n      >\r\n    </div>\r\n  </ng-container>\r\n  <div class=\"radio-option\">\r\n    <mat-radio-group\r\n      [(ngModel)]=\"selectedItem\"\r\n      (ngModelChange)=\"onSelectedItemChanged($event)\"\r\n      class=\"radio-group\"\r\n    >\r\n      <mat-radio-button\r\n        class=\"radio-button\"\r\n        *ngFor=\"let item of data\"\r\n        [value]=\"bindValue ? item[bindValue] : item\"\r\n      >\r\n        {{ (bindLabel ? item[bindLabel] : item) | translate }}\r\n      </mat-radio-button>\r\n    </mat-radio-group>\r\n  </div>\r\n</ng-container>\r\n<!-- template for viewing multi select selected values -->\r\n<!-- [checked]=\"containsValue(bindValue ? item[bindValue] : item,selectedItem)\" -->\r\n", styles: [".radio-label{font-size:17px;margin-bottom:1px}.radio-option{display:flex;grid-column-gap:4px;column-gap:4px}.radio-option .radio-group{display:flex;grid-column-gap:10px;column-gap:10px}.radio-option .mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element{opacity:0!important;background-color:#00dca5!important}.radio-option .mat-radio-button.mat-accent .mat-radio-inner-circle{background-color:#00dca5!important}.radio-option .mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#00dca5!important}\n"], components: [{ type: i2.MatRadioButton, selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.MatRadioGroup, selector: "mat-radio-group", exportAs: ["matRadioGroup"] }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], pipes: { "translate": i4.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: DynamicFormOptionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-dynamic-form-options',
+                    templateUrl: './dynamic-form-options.component.html',
+                    styleUrls: ['./dynamic-form-options.component.scss'],
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { label: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], bindLabel: [{
+                type: Input
+            }], bindValue: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-options.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-options/dynamic-form-options.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-options/dynamic-form-options.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Optional,\r\n  Output,\r\n  Self,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport {\r\n  AbstractControl,\r\n  ControlValueAccessor,\r\n  NgControl,\r\n} from '@angular/forms';\r\nimport { json } from '@rxweb/reactive-form-validators';\r\n/**\r\n * Options group input that can be used inside reactive or template driven forms\r\n * @title\r\n * Options Group\r\n * @example\r\n *   <cts-dynamic-form-options\r\n *    [label]=\"'Choose an item'\"\r\n *    [data]=\"arrayOfItems\"\r\n *    [bindLabel]=\"'name'\"\r\n *    [bindValue]=\"'id'\"\r\n *    [multiple]=\"false\"\r\n *    formControlName=\"option\">\r\n * </cts-dynamic-form-options>\r\n */\r\n@Component({\r\n  selector: 'cts-dynamic-form-options',\r\n  templateUrl: './dynamic-form-options.component.html',\r\n  styleUrls: ['./dynamic-form-options.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class DynamicFormOptionsComponent implements ControlValueAccessor {\r\n  /** Radio group label */\r\n  @Input()\r\n  label;\r\n  /** array of options */\r\n  @Input()\r\n  data;\r\n  /** bind label to option object property */\r\n  @Input() bindLabel: string;\r\n  /** bind value to option object property */\r\n  @Input() bindValue: string;\r\n  /** can select multiple (checkboxes) or (radios) */\r\n  @Input() multiple = false;\r\n  // @Output() onSelectItems = new EventEmitter();\r\n\r\n  selection = [];\r\n  selectedItem: any;\r\n  onChange: any = () => {};\r\n  onTouched: any = () => {};\r\n  constructor(@Self() @Optional() private control: NgControl) {\r\n    this.control.valueAccessor = this;\r\n  }\r\n  ngOnInit(): void { }\r\n\r\n  writeValue(value) {\r\n    if (value && this.multiple) {\r\n      this.selection = [...value];\r\n    }\r\n    if (value && !this.multiple) {\r\n      this.selectedItem = value;\r\n    }\r\n  }\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    throw new Error('Method not implemented.');\r\n  }\r\n  isRequired() {\r\n    if (!this.control || !this.control.control.validator) {\r\n      return false;\r\n    }\r\n\r\n    const validator = this.control.control.validator({} as AbstractControl);\r\n    return validator && validator.required;\r\n  }\r\n\r\n  //multiple functions\r\n  emitSelection(value, isChecked: boolean) {\r\n    if (isChecked) {\r\n      this.selection.push(value);\r\n    } else {\r\n      this.selection = this.selection.filter((item) => {\r\n        return typeof value === 'object'\r\n          ? JSON.stringify(value) != JSON.stringify(item)\r\n          : value != item;\r\n      });\r\n    }\r\n    this.onChange(this.selection);\r\n  }\r\n  containsValue(value, list: any[]) {\r\n    return typeof value === 'object'\r\n      ? list.some((elem) => JSON.stringify(elem) === JSON.stringify(value))\r\n      : list.includes(value);\r\n  }\r\n\r\n  // !multiple functions\r\n  onSelectedItemChanged(event) {\r\n    this.onChange(this.selectedItem);\r\n  }\r\n}\r\n","<!-- template for viewing single select selected value -->\r\n<ng-container *ngIf=\"multiple\">\r\n  <ng-container *ngIf=\"label\">\r\n    <div>\r\n      <label class=\"radio-label\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n      >\r\n    </div>\r\n  </ng-container>\r\n  <div class=\"option-wrapper\" *ngFor=\"let item of data ; let i = index\">\r\n    <span>\r\n      <input\r\n        id=\"item-{{ i }}\"\r\n        type=\"checkbox\"\r\n        (change)=\"\r\n          emitSelection(\r\n            bindValue ? item[bindValue] : item,\r\n            $event.target.checked\r\n          )\r\n        \"\r\n        [checked]=\"containsValue(bindValue ? item[bindValue] : item, selection)\"\r\n      />\r\n    </span>\r\n    <span class=\"label-wrapper\">\r\n      {{ (bindLabel ? item[bindLabel] : item) | translate }}\r\n    </span>\r\n  </div>\r\n</ng-container>\r\n<ng-container *ngIf=\"!multiple\">\r\n  <ng-container *ngIf=\"label\">\r\n    <div>\r\n      <label class=\"radio-label\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span></label\r\n      >\r\n    </div>\r\n  </ng-container>\r\n  <div class=\"radio-option\">\r\n    <mat-radio-group\r\n      [(ngModel)]=\"selectedItem\"\r\n      (ngModelChange)=\"onSelectedItemChanged($event)\"\r\n      class=\"radio-group\"\r\n    >\r\n      <mat-radio-button\r\n        class=\"radio-button\"\r\n        *ngFor=\"let item of data\"\r\n        [value]=\"bindValue ? item[bindValue] : item\"\r\n      >\r\n        {{ (bindLabel ? item[bindLabel] : item) | translate }}\r\n      </mat-radio-button>\r\n    </mat-radio-group>\r\n  </div>\r\n</ng-container>\r\n<!-- template for viewing multi select selected values -->\r\n<!-- [checked]=\"containsValue(bindValue ? item[bindValue] : item,selectedItem)\" -->\r\n"]}