nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/components/dynamic-form/components/dynamic-form-department/services/department-management.service.js

@@ -0,0 +1,104 @@
+import { Inject, Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { catchError, map, take } from 'rxjs/operators';
+import { DepartmentFormComponent } from '../../department-form/department-form.component';
+import { DepartmentConstants } from '../constants/department';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../core/services/nuxeo/nuxeo.service";
+import * as i2 from "../../../../../core/adapters/adapter.service";
+import * as i3 from "../../../../../configuration/app-config.service";
+import * as i4 from "../../../../../../lib/shared/components/nuxeo-dialog/services/nuxeo-dialog.service";
+import * as i5 from "@angular/material/dialog";
+export class DepartmentManagementService {
+    constructor(nuxeoService, adapter, myConfigService, nuxeoDialogService, dialog, environment) {
+        this.nuxeoService = nuxeoService;
+        this.adapter = adapter;
+        this.myConfigService = myConfigService;
+        this.nuxeoDialogService = nuxeoDialogService;
+        this.dialog = dialog;
+        this.environment = environment;
+    }
+    createDepartment(Department, parentId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_Depatrment_Create', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .input(parentId)
+            .context({
+            department: this.adapter.adaptOut(Department, DepartmentConstants.fields)
+        })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    createDepartmentInRoot(Department) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_Depatrment_Create_InRoot', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .context({
+            department: this.adapter.adaptOut(Department, DepartmentConstants.fields)
+        })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    updateDepartment(Department, departmentId) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation('AC_UA_Department_Update', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`
+        })
+            .input(departmentId)
+            .context({
+            department: this.adapter.adaptOut(Department, DepartmentConstants.fields)
+        })
+            .execute()).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    getDepartment(uid) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers({
+            'X-NXproperties': '*'
+        })
+            .fetch(uid)).pipe(map((data) => {
+            return this.adapter.adaptIn(data, DepartmentConstants.fields);
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+    openFormDialog(e = 'root', update = false, displayIsAllowRecExternal, displayDepTypee, depCode, item) {
+        return this.nuxeoDialogService
+            .open({
+            component: DepartmentFormComponent,
+            width: '55%',
+            panelClass: 'department-dialog-container',
+            data: {
+                depId: e,
+                updateMode: update,
+                depCode: depCode,
+                item: item,
+                displayDepTypee: displayDepTypee,
+                displayIsAllowRecExternal: displayIsAllowRecExternal
+            }
+        })
+            .afterClosed()
+            .pipe(take(1));
+    }
+}
+DepartmentManagementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentManagementService, deps: [{ token: i1.NuxeoService }, { token: i2.AdapterService }, { token: i3.AppConfigService }, { token: i4.NuxeoDialogService }, { token: i5.MatDialog }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+DepartmentManagementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentManagementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DepartmentManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NuxeoService }, { type: i2.AdapterService }, { type: i3.AppConfigService }, { type: i4.NuxeoDialogService }, { type: i5.MatDialog }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"department-management.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-department/services/department-management.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { TreeviewItem } from 'ngx-treeview';\r\nimport { from } from 'rxjs';\r\nimport { catchError, map, take } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../../../configuration/app-config.service';\r\nimport { AdapterService } from '../../../../../core/adapters/adapter.service';\r\nimport { NuxeoService } from '../../../../../core/services/nuxeo/nuxeo.service';\r\nimport { DepartmentFormComponent } from '../../department-form/department-form.component';\r\nimport { DepartmentConstants } from '../constants/department';\r\nimport { NuxeoDialogService } from '../../../../../../lib/shared/components/nuxeo-dialog/services/nuxeo-dialog.service';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class DepartmentManagementService {\r\n\tconstructor(\r\n\t\tprivate nuxeoService: NuxeoService,\r\n\t\tprivate adapter: AdapterService,\r\n\t\tprivate myConfigService: AppConfigService,\r\n\t\tpublic nuxeoDialogService: NuxeoDialogService,\r\n\t\tprivate dialog: MatDialog,\r\n\t\t@Inject('environment') private environment\r\n\t) {}\r\n\tcreateDepartment(Department, parentId) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation('AC_UA_Depatrment_Create', {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.input(parentId)\r\n\t\t\t\t.context({\r\n\t\t\t\t\tdepartment: this.adapter.adaptOut(\r\n\t\t\t\t\t\tDepartment,\r\n\t\t\t\t\t\tDepartmentConstants.fields\r\n\t\t\t\t\t)\r\n\t\t\t\t})\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\tcreateDepartmentInRoot(Department) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation('AC_UA_Depatrment_Create_InRoot', {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.context({\r\n\t\t\t\t\tdepartment: this.adapter.adaptOut(\r\n\t\t\t\t\t\tDepartment,\r\n\t\t\t\t\t\tDepartmentConstants.fields\r\n\t\t\t\t\t)\r\n\t\t\t\t})\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\tupdateDepartment(Department, departmentId) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.operation('AC_UA_Department_Update', {\r\n\t\t\t\t\turl: `${this.environment.nuxeo}${this.environment.customAutomation}`\r\n\t\t\t\t})\r\n\t\t\t\t.input(departmentId)\r\n\t\t\t\t.context({\r\n\t\t\t\t\tdepartment: this.adapter.adaptOut(\r\n\t\t\t\t\t\tDepartment,\r\n\t\t\t\t\t\tDepartmentConstants.fields\r\n\t\t\t\t\t)\r\n\t\t\t\t})\r\n\t\t\t\t.execute()\r\n\t\t).pipe(\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tconsole.log(err);\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\tgetDepartment(uid) {\r\n\t\treturn from(\r\n\t\t\tthis.nuxeoService.nuxeoClient\r\n\t\t\t\t.repository()\r\n\t\t\t\t.headers({\r\n\t\t\t\t\t'X-NXproperties': '*'\r\n\t\t\t\t})\r\n\t\t\t\t.fetch(uid)\r\n\t\t).pipe(\r\n\t\t\tmap((data: any) => {\r\n\t\t\t\treturn this.adapter.adaptIn(data, DepartmentConstants.fields);\r\n\t\t\t}),\r\n\t\t\tcatchError((err) => {\r\n\t\t\t\tthrow err;\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\topenFormDialog(\r\n\t\te: string = 'root',\r\n\t\tupdate: boolean = false,\r\n\t\tdisplayIsAllowRecExternal,\r\n\t\tdisplayDepTypee,\r\n\t\tdepCode?,\r\n\t\titem?: TreeviewItem\r\n\t) {\r\n\t\treturn this.nuxeoDialogService\r\n\t\t\t.open({\r\n\t\t\t\tcomponent: DepartmentFormComponent,\r\n\t\t\t\twidth: '55%',\r\n\t\t\t\tpanelClass: 'department-dialog-container',\r\n\t\t\t\tdata: {\r\n\t\t\t\t\tdepId: e,\r\n\t\t\t\t\tupdateMode: update,\r\n\t\t\t\t\tdepCode: depCode,\r\n\t\t\t\t\titem: item,\r\n\t\t\t\t\tdisplayDepTypee: displayDepTypee,\r\n\t\t\t\t\tdisplayIsAllowRecExternal: displayIsAllowRecExternal\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.afterClosed()\r\n\t\t\t.pipe(take(1));\r\n\t}\r\n}\r\n// .subscribe((data) => {\r\n//   if (data) {\r\n//     if (typeof data === 'object' && data.item.value.level == 2) {\r\n//       return;\r\n//     } else {\r\n//       // this.department.getLisOfOptions();\r\n//     }\r\n//   }\r\n// });\r\n"]}

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

@@ -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.17", 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.17", 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.17", 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

@@ -0,0 +1,152 @@
+import { Component, ViewChild, Optional, Self, Input, ViewEncapsulation, EventEmitter, Output } from '@angular/core';
+import { NgbDate } from '@ng-bootstrap/ng-bootstrap';
+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, _cdr) {
+        this.dateFormatterService = dateFormatterService;
+        this.control = control;
+        this._cdr = _cdr;
+        /** Minimum Hijri Date */
+        this.minHijri = this.getHijriDateMinusYears(50);
+        /** Minimum Gregorian Date */
+        this.minGreg = this.getGregDateMinusYears(50);
+        /** 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.date = null;
+        this.selectedDateType = DateType.Gregorian;
+        this.emitOnBlur = true;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.control.valueAccessor = this;
+    }
+    getGregDateMinusYears(years) {
+        const today = this.dateFormatterService.GetTodayGregorian();
+        return new NgbDate(today.year - years, today.month, today.day);
+    }
+    getHijriDateMinusYears(years) {
+        const today = this.dateFormatterService.GetTodayHijri();
+        return new NgbDate(today.year - years, today.month, today.day);
+    }
+    writeValue(obj) {
+        if (!obj) {
+            this.date = null;
+            this._cdr.markForCheck();
+            return;
+        }
+        this.date = this.range
+            ? this._convertRangeToGregorian(obj)
+            : this.dateFormatterService.ToGregorianDateStruct(obj, '');
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    ngOnInit() {
+        this.placeHolder = this.placeholder ? this.placeholder : 'datePlaceHolder';
+    }
+    setValue(event) {
+        const dateString = this.startDatePicker.getSelectedDate();
+        if (!event || dateString === 'Invalid date') {
+            this.dateString = null;
+            this.onChange(null);
+            this.valueChanged.emit(null);
+            return;
+        }
+        this.dateString = dateString;
+        this.onChange(this.dateString);
+        this.valueChanged.emit(this.dateString);
+    }
+    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;
+    }
+    _convertRangeToGregorian(obj) {
+        return obj.from && obj.to
+            ? {
+                from: this.dateFormatterService.ToGregorianDateStruct(obj.from, ''),
+                to: this.dateFormatterService.ToGregorianDateStruct(obj.to, '')
+            }
+            : null;
+    }
+}
+DynamicFormHijriDateitemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormHijriDateitemComponent, deps: [{ token: i1.DateFormatterService }, { token: i2.NgControl, optional: true, self: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormHijriDateitemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", 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", emitOnBlur: "emitOnBlur" }, outputs: { valueChanged: "valueChanged" }, viewQueries: [{ propertyName: "startDatePicker", first: true, predicate: ["datePicker"], descendants: true }], ngImport: i0, template: "<ng-container *ngIf=\"label\">\r\n  <div class=\"flex\">\r\n    <label class=\"hijri-date-lable\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger mx-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    [emitOnBlur]=\"emitOnBlur\"\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", "emitOnBlur"], 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.17", 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
+                }] }, { type: i0.ChangeDetectorRef }]; }, 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
+            }], emitOnBlur: [{
+                type: Input
+            }], 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\tComponent,\r\n\tViewChild,\r\n\tOnInit,\r\n\tOptional,\r\n\tSelf,\r\n\tInput,\r\n\tViewEncapsulation,\r\n\tEventEmitter,\r\n\tOutput,\r\n\tChangeDetectorRef\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 { AbstractControl, ControlValueAccessor, NgControl } 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/**\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\tselector: 'cts-dynamic-form-hijri-dateitem',\r\n\ttemplateUrl: './dynamic-form-hijri-dateitem.component.html',\r\n\tstyleUrls: ['./dynamic-form-hijri-dateitem.component.scss'],\r\n\tencapsulation: ViewEncapsulation.None\r\n})\r\nexport class DynamicFormHijriDateitemComponent implements OnInit, ControlValueAccessor {\r\n\t/** Minimum Hijri Date */\r\n\t@Input()\r\n\tminHijri: NgbDate = this.getHijriDateMinusYears(50);\r\n\t/** Max Hijri Date */\r\n\t@Input()\r\n\tmaxHijri: NgbDate;\r\n\t/** Minimum Gregorian Date */\r\n\t@Input()\r\n\tminGreg: NgbDate = this.getGregDateMinusYears(50);\r\n\t/** Max Gregorian Date */\r\n\t@Input()\r\n\tmaxGreg: NgbDate;\r\n\t/** Field Label */\r\n\t@Input()\r\n\tlabel;\r\n\t/** Is input disabled */\r\n\t@Input()\r\n\tisDisabled: boolean;\r\n\t/** is input a range picker */\r\n\t@Input()\r\n\trange: boolean;\r\n\t/** list inputs vertically (for range only) */\r\n\t@Input()\r\n\tvertical = false;\r\n\t/** Sets picker to readonly mode */\r\n\t@Input()\r\n\tisReadOnly: boolean = true;\r\n\t@Input()\r\n\tplaceholder: string;\r\n\t/** Emitted when the value changes */\r\n\t@Output()\r\n\tvalueChanged: EventEmitter<any> = new EventEmitter();\r\n\tdate: any = null;\r\n\tdateString: string;\r\n\tplaceHolder: string;\r\n\tselectedDateType = DateType.Gregorian;\r\n\r\n\t@Input() emitOnBlur = true;\r\n\r\n\tonChange: any = () => {};\r\n\tonTouched: any = () => {};\r\n\r\n\t@ViewChild('datePicker') startDatePicker: any;\r\n\r\n\tgetGregDateMinusYears(years: number): NgbDate {\r\n\t\tconst today = this.dateFormatterService.GetTodayGregorian();\r\n\t\treturn new NgbDate(today.year - years, today.month, today.day);\r\n\t}\r\n\r\n\tgetHijriDateMinusYears(years: number): NgbDate {\r\n\t\tconst today = this.dateFormatterService.GetTodayHijri();\r\n\t\treturn new NgbDate(today.year - years, today.month, today.day);\r\n\t}\r\n\r\n\tconstructor(\r\n\t\tprivate dateFormatterService: DateFormatterService,\r\n\t\t@Self() @Optional() private control: NgControl,\r\n\t\tprivate _cdr: ChangeDetectorRef\r\n\t) {\r\n\t\tthis.control.valueAccessor = this;\r\n\t}\r\n\twriteValue(obj: any): void {\r\n\t\tif (!obj) {\r\n\t\t\tthis.date = null;\r\n\t\t\tthis._cdr.markForCheck();\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.date = this.range\r\n\t\t\t? this._convertRangeToGregorian(obj)\r\n\t\t\t: this.dateFormatterService.ToGregorianDateStruct(obj, '');\r\n\t}\r\n\r\n\tregisterOnChange(fn: any): void {\r\n\t\tthis.onChange = fn;\r\n\t}\r\n\tregisterOnTouched(fn: any): void {\r\n\t\tthis.onTouched = fn;\r\n\t}\r\n\tsetDisabledState?(isDisabled: boolean): void {\r\n\t\tthis.isDisabled = isDisabled;\r\n\t}\r\n\r\n\tngOnInit(): void {\r\n\t\tthis.placeHolder = this.placeholder ? this.placeholder : 'datePlaceHolder';\r\n\t}\r\n\r\n\tsetValue(event: { day: number; month: number; year: number } | null) {\r\n\t\tconst dateString = this.startDatePicker.getSelectedDate();\r\n\t\tif (!event || dateString === 'Invalid date') {\r\n\t\t\tthis.dateString = null;\r\n\t\t\tthis.onChange(null);\r\n\t\t\tthis.valueChanged.emit(null);\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tthis.dateString = dateString;\r\n\t\tthis.onChange(this.dateString);\r\n\t\tthis.valueChanged.emit(this.dateString);\r\n\t}\r\n\r\n\tisRequired() {\r\n\t\tif (!this.control?.control || !this.control.control.validator) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tconst validator = this.control.control.validator({} as AbstractControl);\r\n\t\treturn validator && validator.required;\r\n\t}\r\n\r\n\tprivate _convertRangeToGregorian(obj: any): { from: any; to: any } | null {\r\n\t\treturn obj.from && obj.to\r\n\t\t\t? {\r\n\t\t\t\t\tfrom: this.dateFormatterService.ToGregorianDateStruct(obj.from, ''),\r\n\t\t\t\t\tto: this.dateFormatterService.ToGregorianDateStruct(obj.to, '')\r\n\t\t\t\t}\r\n\t\t\t: null;\r\n\t}\r\n}\r\n","<ng-container *ngIf=\"label\">\r\n  <div class=\"flex\">\r\n    <label class=\"hijri-date-lable\"\r\n      >{{ label | translate\r\n      }}<span *ngIf=\"isRequired()\" class=\"text-danger mx-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    [emitOnBlur]=\"emitOnBlur\"\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

@@ -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.17", 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.17", 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.17", 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

@@ -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.17", ngImport: i0, type: DynamicFormMapItemComponent, deps: [{ token: i1.DynamicFormUpdateService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormMapItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", 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.17", 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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