nuxeo-development-framework 0.0.0-watch

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

@@ -0,0 +1,165 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { Components, FormBuilderComponent } from 'angular-formio';
+import { Utils } from 'formiojs';
+import { cloneDeep } from 'lodash';
+import { baseEditForm } from '../form-wrappers/base-edit-form/base-edit-form';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-formio";
+import * as i2 from "../../../../shared/components/button/button.component";
+import * as i3 from "@angular/cdk/bidi";
+import * as i4 from "@ngx-translate/core";
+export class DynamicFormBuilderComponent {
+    constructor() {
+        this.form = {};
+        this.builder = {};
+        this.builderComponents = {};
+        this.formUpdated = new EventEmitter();
+        this.saving = false;
+        this.builderOptions = {
+            noDefaultSubmitButton: true,
+            builder: {
+                basic: false,
+                advanced: false,
+                data: false,
+                premium: false,
+                layout: {
+                    components: {
+                        htmlelement: false,
+                        content: false
+                    }
+                },
+                customBasic: {
+                    title: 'Basic Components',
+                    default: true,
+                    weight: 0,
+                    components: {}
+                }
+            },
+            editForm: {
+                textfield: [
+                    {
+                        key: 'api',
+                        ignore: true
+                    },
+                    {
+                        key: 'logic',
+                        ignore: true
+                    },
+                    {
+                        key: 'layout',
+                        ignore: true
+                    }
+                ],
+                number: [
+                    {
+                        key: 'display'
+                    },
+                    {
+                        key: 'api',
+                        ignore: true
+                    },
+                    {
+                        key: 'logic',
+                        ignore: true
+                    },
+                    {
+                        key: 'layout',
+                        ignore: true
+                    }
+                ]
+            }
+        };
+        this.refresher = new EventEmitter();
+        this.deletedComponents = {};
+        // tslint:disable-next-line:variable-name
+        this._form = {};
+        const numberEditForm = Components.components.number.editForm();
+        const textEditForm = Components.components.textfield.editForm();
+        textEditForm.components[0].components[1].components = textEditForm.components[0].components[1].components.filter(item => !['persistent', 'protected', 'dbIndex', 'encrypted', 'calculateServer'].includes(item.key));
+        numberEditForm.components[0].components[1].components = numberEditForm.components[0].components[1].components.filter(item => !['persistent', 'protected', 'dbIndex', 'encrypted', 'calculateServer'].includes(item.key));
+        Components.components.textfield.editForm = () => baseEditForm([textEditForm.components[0].components[1]]);
+        Components.components.number.editForm = () => baseEditForm([numberEditForm.components[0].components[1]]);
+        this._form = this.form;
+    }
+    ngOnInit() {
+    }
+    ngOnChanges(changes) {
+        if (changes.form || changes.builderComponents) {
+            if (this.form.components) {
+                Utils.eachComponent(this.form.components, (comp) => {
+                    if (this.builderComponents[comp.key]) {
+                        this.deletedComponents[comp.key] = cloneDeep(this.builderComponents[comp.key]);
+                        delete this.builderComponents[comp.key];
+                    }
+                    else if (Object.keys(this.builderComponents).length) {
+                        Utils.findComponent(this.form.components, comp.key, null, (found, path) => {
+                            Utils.removeComponent(this.form.components, path);
+                            this._form = cloneDeep(this.form);
+                        });
+                    }
+                });
+            }
+            this.builderOptions.builder.customBasic.components = cloneDeep(this.builderComponents);
+            this.refresher.next();
+        }
+    }
+    save() {
+        this.saving = true;
+        this.form = cloneDeep(this._form);
+        this.formUpdated.next(this.form);
+        setTimeout(() => {
+            this.saving = false;
+        }, 500);
+    }
+    onChange(event) {
+        this.handleComponentChange(event.component, event.type);
+        if (['addComponent', 'saveComponent', 'deleteComponent'].indexOf(event.type) > -1) {
+            this._form = cloneDeep(event.form);
+        }
+    }
+    handleComponentChange(component, eventType) {
+        if (component.fixedKey) {
+            component.key = component.fixedKey;
+            if (component.fixedKey && this.builderOptions.builder.customBasic.components[component.fixedKey] && eventType === 'addComponent') {
+                this.deletedComponents[component.fixedKey] = Object.assign({}, this.builderOptions.builder.customBasic.components[component.fixedKey]);
+                this.builderOptions.builder.customBasic.components[component.fixedKey] = false;
+            }
+            if (component.fixedKey && this.deletedComponents[component.fixedKey] && eventType === 'deleteComponent') {
+                this.builderOptions.builder.customBasic.components[component.fixedKey] = Object.assign({}, this.deletedComponents[component.fixedKey]);
+                delete this.deletedComponents[component.fixedKey];
+            }
+            this.refresher.next();
+        }
+        else {
+            Utils.eachComponent([component], (comp) => {
+                this.handleComponentChange(comp, eventType);
+            });
+        }
+    }
+}
+DynamicFormBuilderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormBuilderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormBuilderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFormBuilderComponent, selector: "app-dynamic-form-builder", inputs: { form: "form", builder: "builder", builderComponents: "builderComponents" }, outputs: { formUpdated: "formUpdated" }, viewQueries: [{ propertyName: "jsonElement", first: true, predicate: ["json"], descendants: true }, { propertyName: "FormBuilderComponent", first: true, predicate: FormBuilderComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"container-fluid\" dir=\"ltr\">\r\n  <form-builder [form]=\"form\" [options]=\"builderOptions\" [rebuild]=\"refresher\" (change)=\"onChange($event)\"></form-builder>\r\n  <!-- <button class=\"save-form\" (click)=\"save()\">SAVE</button> -->\r\n  <div class=\"mx-2 save-form\">\r\n    <cts-button\r\n    [loading]=\"saving\"\r\n    [theme]=\"'primary'\"\r\n    [size]=\"'regular'\"\r\n    (onClick)=\"save()\"\r\n    \r\n  >\r\n    {{ \"BUTTONS.SAVE\" | translate }}\r\n  </cts-button>\r\n  </div>\r\n</div>\r\n", styles: [".formio-dialog{direction:ltr;text-align:left}.formio-dialog .card-title{border:0px!important}.builder{text-align:left}.builder div[ref=copyComponent],.builder div[ref=pasteComponent],.builder div[ref=editJson]{display:none;visibility:hidden}.builder .formarea{flex:0 0 75%}.builder .formarea .formio-component .formio-form .builder-component .form-group label{color:#646f85;font-size:13px}.builder .formarea .formio-component .formio-form .builder-component .form-group input{border:1px solid #ccc;border-radius:5px;background-color:#8f98aa1a;height:40px}.builder .formarea .formio-component .formio-form .builder-component .formio-component-vocabulary input{border:none;background:no-repeat;height:40px}.builder .formcomponents{flex:0 0 25%;max-width:25%}.builder .formcomponents .builder-sidebar .form-builder-panel .show .card-body{width:80%}.builder .formcomponents .builder-sidebar .form-builder-panel .show .card-body .formcomponent{width:100%;overflow:hidden;white-space:nowrap!important;text-overflow:ellipsis}.container-fluid .save-form{margin-top:15px;width:200px}\n"], components: [{ type: i1.FormBuilderComponent, selector: "form-builder", inputs: ["noeval", "form", "options", "formbuilder", "refresh", "rebuild"], outputs: ["change"] }, { type: i2.ButtonComponent, selector: "cts-button", inputs: ["disabled", "loading", "size", "theme", "spinnerTheming"], outputs: ["onClick"] }], directives: [{ type: i3.Dir, selector: "[dir]", inputs: ["dir"], outputs: ["dirChange"], exportAs: ["dir"] }], pipes: { "translate": i4.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormBuilderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-dynamic-form-builder',
+                    templateUrl: './dynamic-form-builder.component.html',
+                    styleUrls: ['./dynamic-form-builder.component.scss'],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { jsonElement: [{
+                type: ViewChild,
+                args: ['json']
+            }], form: [{
+                type: Input
+            }], builder: [{
+                type: Input
+            }], builderComponents: [{
+                type: Input
+            }], formUpdated: [{
+                type: Output
+            }], FormBuilderComponent: [{
+                type: ViewChild,
+                args: [FormBuilderComponent, { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-builder.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-builder/dynamic-form-builder.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-builder/dynamic-form-builder.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component, ElementRef, EventEmitter, Input, OnChanges, OnInit, Output, ViewChild, ViewEncapsulation\r\n} from '@angular/core';\r\nimport { Components, FormBuilderComponent } from 'angular-formio';\r\nimport { Utils } from 'formiojs';\r\nimport { cloneDeep } from 'lodash';\r\nimport { baseEditForm } from '../form-wrappers/base-edit-form/base-edit-form';\r\n@Component({\r\n  selector: 'app-dynamic-form-builder',\r\n  templateUrl: './dynamic-form-builder.component.html',\r\n  styleUrls: ['./dynamic-form-builder.component.scss'],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class DynamicFormBuilderComponent implements OnChanges, OnInit {\r\n  @ViewChild('json') jsonElement?: ElementRef;\r\n  @Input()\r\n  form: any = {};\r\n  @Input()\r\n  builder: any = {};\r\n  @Input()\r\n  builderComponents = {};\r\n  @Output()\r\n  formUpdated = new EventEmitter();\r\n  saving = false;\r\n  @ViewChild(FormBuilderComponent, { static: false }) FormBuilderComponent: FormBuilderComponent;\r\n  builderOptions = {\r\n    noDefaultSubmitButton: true,\r\n    builder: {\r\n      basic: false,\r\n      advanced: false,\r\n      data: false,\r\n      premium: false,\r\n      layout: {\r\n        components: {\r\n          htmlelement: false,\r\n          content: false\r\n        }\r\n      },\r\n      customBasic: {\r\n        title: 'Basic Components',\r\n        default: true,\r\n        weight: 0,\r\n        components: {}\r\n      }\r\n    },\r\n    editForm: {\r\n      textfield: [\r\n\r\n        {\r\n          key: 'api',\r\n          ignore: true\r\n        },\r\n        {\r\n          key: 'logic',\r\n          ignore: true\r\n        },\r\n        {\r\n          key: 'layout',\r\n          ignore: true\r\n        }\r\n      ],\r\n      number: [\r\n        {\r\n          key: 'display'\r\n        },\r\n        {\r\n          key: 'api',\r\n          ignore: true\r\n        },\r\n        {\r\n          key: 'logic',\r\n          ignore: true\r\n        },\r\n        {\r\n          key: 'layout',\r\n          ignore: true\r\n        }\r\n      ]\r\n    }\r\n  };\r\n  refresher = new EventEmitter();\r\n  deletedComponents = {};\r\n  // tslint:disable-next-line:variable-name\r\n  private _form: any = {};\r\n\r\n  constructor() {\r\n    const numberEditForm = Components.components.number.editForm();\r\n    const textEditForm = Components.components.textfield.editForm();\r\n    textEditForm.components[0].components[1].components = textEditForm.components[0].components[1].components.filter(item => !['persistent', 'protected', 'dbIndex', 'encrypted', 'calculateServer'].includes(item.key));\r\n    numberEditForm.components[0].components[1].components = numberEditForm.components[0].components[1].components.filter(item => !['persistent', 'protected', 'dbIndex', 'encrypted', 'calculateServer'].includes(item.key));\r\n    Components.components.textfield.editForm = () =>\r\n      baseEditForm([textEditForm.components[0].components[1]]);\r\n    Components.components.number.editForm = () =>\r\n      baseEditForm([numberEditForm.components[0].components[1]]);\r\n    this._form = this.form;\r\n  }\r\n  ngOnInit() {\r\n\r\n  }\r\n  ngOnChanges(changes) {\r\n    if (changes.form || changes.builderComponents) {\r\n      if (this.form.components) {\r\n        Utils.eachComponent(this.form.components, (comp) => {\r\n          if (this.builderComponents[comp.key]) {\r\n            this.deletedComponents[comp.key] = cloneDeep(this.builderComponents[comp.key]);\r\n            delete this.builderComponents[comp.key];\r\n          } else if (Object.keys(this.builderComponents).length) {\r\n            Utils.findComponent(this.form.components, comp.key, null, (found, path) => {\r\n              Utils.removeComponent(this.form.components, path);\r\n              this._form = cloneDeep(this.form);\r\n            });\r\n          }\r\n        });\r\n      }\r\n      this.builderOptions.builder.customBasic.components = cloneDeep(this.builderComponents);\r\n\r\n\r\n      this.refresher.next();\r\n    }\r\n  }\r\n  save() {\r\n    this.saving = true;\r\n    this.form = cloneDeep(this._form);\r\n    this.formUpdated.next(this.form);\r\n    setTimeout(() => {\r\n      this.saving = false;\r\n    }, 500);\r\n  }\r\n  onChange(event: any) {\r\n    this.handleComponentChange(event.component, event.type);\r\n\r\n    if (['addComponent', 'saveComponent', 'deleteComponent'].indexOf(event.type) > -1) {\r\n      this._form = cloneDeep(event.form);\r\n    }\r\n\r\n  }\r\n\r\n  handleComponentChange(component, eventType): void {\r\n    if (component.fixedKey) {\r\n      component.key = component.fixedKey;\r\n      if (component.fixedKey && this.builderOptions.builder.customBasic.components[component.fixedKey] && eventType === 'addComponent') {\r\n        this.deletedComponents[component.fixedKey] =\r\n          { ...this.builderOptions.builder.customBasic.components[component.fixedKey] };\r\n        this.builderOptions.builder.customBasic.components[component.fixedKey] = false;\r\n      }\r\n      if (component.fixedKey && this.deletedComponents[component.fixedKey] && eventType === 'deleteComponent') {\r\n        this.builderOptions.builder.customBasic.components[component.fixedKey] =\r\n          { ... this.deletedComponents[component.fixedKey] };\r\n        delete this.deletedComponents[component.fixedKey];\r\n      }\r\n      this.refresher.next();\r\n\r\n    } else {\r\n      Utils.eachComponent([component], (comp) => {\r\n        this.handleComponentChange(comp, eventType);\r\n      });\r\n    }\r\n  }\r\n\r\n\r\n}\r\n","<div class=\"container-fluid\" dir=\"ltr\">\r\n  <form-builder [form]=\"form\" [options]=\"builderOptions\" [rebuild]=\"refresher\" (change)=\"onChange($event)\"></form-builder>\r\n  <!-- <button class=\"save-form\" (click)=\"save()\">SAVE</button> -->\r\n  <div class=\"mx-2 save-form\">\r\n    <cts-button\r\n    [loading]=\"saving\"\r\n    [theme]=\"'primary'\"\r\n    [size]=\"'regular'\"\r\n    (onClick)=\"save()\"\r\n    \r\n  >\r\n    {{ \"BUTTONS.SAVE\" | translate }}\r\n  </cts-button>\r\n  </div>\r\n</div>\r\n"]}

package/esm2015/lib/components/dynamic-form/components/dynamic-form-checkbox-item/dynamic-form-checkbox-item.component.js

@@ -0,0 +1,71 @@
+import { Component, Input, Optional, Self, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/forms";
+/**
+ * A checkbox input that can be used inside reactive or template driven forms
+ * @title
+ * Checkbox
+ * @example
+ *   <cts-dynamic-form-checkbox-item
+ *     [label]="'test slide'"
+ *     formControlName="checkbox"
+ * ></cts-dynamic-form-checkbox-item>
+ */
+export class DynamicFormCheckboxItemComponent {
+    constructor(translate, control) {
+        this.translate = translate;
+        this.control = control;
+        /** set input to disabled */
+        this.disabled = false;
+        /** is checkbox checked */
+        this.checked = false;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.control.valueAccessor = this;
+    }
+    writeValue(obj) {
+        this.value = obj;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    isRequired() {
+        if (!this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return validator && validator.required;
+    }
+    setValue(event) {
+        this.onChange(event.target.checked);
+    }
+}
+DynamicFormCheckboxItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormCheckboxItemComponent, deps: [{ token: i1.TranslateService }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormCheckboxItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFormCheckboxItemComponent, selector: "cts-dynamic-form-checkbox-item", inputs: { label: "label", disabled: "disabled", checked: "checked" }, ngImport: i0, template: "<div class=\"checkbox-container\">\r\n  <input\r\n    [checked]=\"checked\"\r\n    [disabled]=\"disabled\"\r\n    [(ngModel)]=\"value\"\r\n    (change)=\"setValue($event)\"\r\n    type=\"checkbox\"\r\n  />\r\n  <label class=\"checkbox-lable\">{{ label | translate }}</label>\r\n</div>\r\n", styles: [".checkbox-lable{color:#8f98aa;font-size:16px;margin-bottom:0}.checkbox-container{display:flex;align-items:center;grid-column-gap:4px;column-gap:4px}.checkbox-container input[type=checkbox]{transform:scale(1.2)}\n"], directives: [{ type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], pipes: { "translate": i1.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormCheckboxItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-dynamic-form-checkbox-item',
+                    templateUrl: './dynamic-form-checkbox-item.component.html',
+                    styleUrls: ['./dynamic-form-checkbox-item.component.scss'],
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { label: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,213 @@
+import { Component, Input, Optional, Self, ViewChild, ViewEncapsulation } from '@angular/core';
+import { OWL_DATE_TIME_FORMATS } from '@busacca/ng-pick-datetime';
+import moment from 'moment-es6';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { UserPreferenceValues } from '../../../../core/services/user/user-preferences.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/dynamic-form-update.service";
+import * as i2 from "@angular/material/core";
+import * as i3 from "../../../../core/services/user/user-preferences.service";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/forms";
+import * as i6 from "@busacca/ng-pick-datetime";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/form-field";
+export const MY_MOMENT_FORMATS = {
+    parseInput: 'l LT',
+    fullPickerInput: 'l LT',
+    datePickerInput: 'l',
+    timePickerInput: 'LT',
+    monthYearLabel: 'MMM YYYY',
+    dateA11yLabel: 'LL',
+    monthYearA11yLabel: 'MMMM YYYY',
+};
+/** @ignore */
+export class DynamicFormDateItemComponent {
+    constructor(dynamicFormUpdateService, dateAdapter, userPreferencesService, translate, control) {
+        this.dynamicFormUpdateService = dynamicFormUpdateService;
+        this.dateAdapter = dateAdapter;
+        this.userPreferencesService = userPreferencesService;
+        this.translate = translate;
+        this.control = control;
+        this.disabled = false;
+        this.inEdit = false;
+        this.editable = true;
+        this.displayEmpty = true;
+        this.min = null;
+        this.max = null;
+        this.startAt = null;
+        this.displayClearAction = true;
+        this.pickerType = 'both';
+        this.selectMode = 'single';
+        this.isfilter = false; // showed error when building lib that this property is not exist 
+        this.placeholder = ''; // showed error when building lib that this property is not exist 
+        this.displayedTime = '';
+        this.onDestroy$ = new Subject();
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.control.valueAccessor = this;
+        this.dateFormat = 'mediumDate';
+    }
+    isRequired() {
+        if (!this.control.control.validator) {
+            return false;
+        }
+        const validator = this.control.control.validator({});
+        return (validator && validator.required);
+    }
+    writeValue(obj) {
+        if (this.selectMode === 'single') {
+            if (obj) {
+                moment.locale('en-au');
+                this.valueDate = obj;
+                this.displayedTime = moment(obj).format("HH:mm");
+            }
+            else {
+                this.displayedTime = '';
+            }
+        }
+        else {
+            this.valueDate = obj;
+        }
+        // this.property.value = obj;
+        //  throw new Error('Method not implemented.');
+    }
+    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;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    hasErrors() {
+        return this.showError;
+    }
+    ngOnInit() {
+        this.userPreferencesService
+            .select(UserPreferenceValues.Locale)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe(locale => {
+            // this.dateAdapter.setLocale(locale);
+            // this.property.locale = locale;
+        });
+        this.dateAdapter.overrideDisplayFormat = 'DD/MM/YYYY';
+        /* if (this.property.value) {
+           this.valueDate = moment(this.property.value);
+         } */
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    showProperty() {
+        return this.displayEmpty || !this.property.isEmpty();
+    }
+    showClearAction() {
+        return (this.displayClearAction &&
+            (!this.property.isEmpty() || !!this.property.default));
+    }
+    isEditable() {
+        return this.editable;
+    }
+    isDisabled() {
+        return this.disabled;
+    }
+    showDatePicker() {
+        this.datepicker.open();
+    }
+    onDateChanged(newDateValue) {
+        if (this.valueDate) {
+            if (this.selectMode === 'single') {
+                moment.locale('en-au');
+                const momentDate = moment(this.valueDate, this.dateFormat, true);
+                if (momentDate.isValid()) {
+                    //this.property.value = momentDate.toDate();
+                    this.onChange(momentDate.toDate());
+                    this.onTouched();
+                    // this.dynamicFormUpdateService.update(this.property, momentDate.toDate());
+                }
+                this.displayedTime = moment(this.valueDate).format("HH:mm");
+            }
+            else {
+                this.onChange(this.valueDate);
+                this.onTouched();
+            }
+        }
+        else {
+            this.onChange(null);
+            this.onTouched();
+        }
+    }
+    onDateClear() {
+        this.valueDate = null;
+        this.onChange(this.valueDate);
+        this.onTouched();
+        this.displayedTime = '';
+        // this.dynamicFormUpdateService.update(this.property, null);
+        //this.property.value = null;
+        this.property ? this.property.default = null : '';
+    }
+}
+DynamicFormDateItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormDateItemComponent, deps: [{ token: i1.DynamicFormUpdateService }, { token: i2.DateAdapter }, { token: i3.UserPreferencesService }, { token: i4.TranslateService }, { token: i5.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicFormDateItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DynamicFormDateItemComponent, selector: "app-dynamic-form-dateitem", inputs: { label: "label", disabled: "disabled", property: "property", editable: "editable", displayEmpty: "displayEmpty", min: "min", max: "max", startAt: "startAt", displayClearAction: "displayClearAction", pickerType: "pickerType", selectMode: "selectMode", isfilter: "isfilter", placeholder: "placeholder" }, providers: [
+        { provide: OWL_DATE_TIME_FORMATS, useValue: MY_MOMENT_FORMATS }
+    ], viewQueries: [{ propertyName: "datepicker", first: true, predicate: ["datetimePicker"], descendants: true }], ngImport: i0, template: "<div class=\"app-property-value\">\r\n  <div class=\"app-input-wrapper\">\r\n    <ng-container *ngIf=\"label\">\r\n      <label class=\"\" for=\"formGroupInputSmall\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span>\r\n      </label>\r\n    </ng-container>\r\n    <div class=\"input-container\">\r\n      <ng-container *ngIf=\"isEditable(); else readOnly\">\r\n\r\n        <button *ngIf=\"!isfilter && pickerType !== 'timer'\" type=\"button\" class=\"claendar-icon\" [owlDateTimeTrigger]=\"dt3\">\r\n          <i class=\"bi bi-calendar-week icon\"></i>        </button>\r\n\r\n          <button *ngIf=\"!isfilter && pickerType === 'timer'\" type=\"button\" class=\"claendar-icon\" [owlDateTimeTrigger]=\"dt3\">\r\n            <i class=\"bi bi-clock icon\"></i>        </button>\r\n        <input\r\n          class=\"form-control date\"\r\n          [disabled]=\"isDisabled() || null\"\r\n          (blur)=\"onTouched($event)\"\r\n          [min]=\"min\"\r\n          [max]=\"max\"\r\n          [selectMode]=\"selectMode\"\r\n          [required]=\"isRequired\"\r\n          [(ngModel)]=\"valueDate\"\r\n          (ngModelChange)=\"onDateChanged($event)\"\r\n          autocomplete=\"false\"\r\n          [owlDateTimeTrigger]=\"dt3\"\r\n          [owlDateTime]=\"dt3\"\r\n          placeholder=\"{{ placeholder }}\"\r\n        />\r\n        <input\r\n        class=\"form-control timer\"\r\n        [disabled]=\"true\"\r\n        [required]=\"isRequired\"\r\n        [(ngModel)]=\"displayedTime\"\r\n        placeholder=\"{{ placeholder }}\"\r\n      />\r\n\r\n        <button type=\"button\" *ngIf=\"valueDate\" (click)=\"onDateClear()\" class=\"relative mx-1 clear-date-btn\"\r\n        [ngClass]=\"{'d-none': isDisabled()}\">\r\n          <i class=\"clear-date-icon material-icons  flex mr-1\">&#xE14C;</i>\r\n        </button>\r\n        <owl-date-time\r\n          [startAt]=\"startAt\"\r\n          [pickerType]=\"pickerType\"\r\n          #dt3\r\n        ></owl-date-time>\r\n\r\n        <mat-error\r\n          [attr.data-automation-id]=\"'card-textitem-error-'\"\r\n          class=\"app-textitem-editable-error\"\r\n          *ngIf=\"hasErrors()\"\r\n        >\r\n          <ul>\r\n            <li *ngIf=\"control.errors.required\">\r\n             <span *ngIf=\"label\" class=\"mx-1\">{{ label | translate}}</span> {{ \"VALIDATORS.REQUIRED\" | translate }}\r\n            </li>\r\n          </ul>\r\n        </mat-error>\r\n      </ng-container>\r\n      <ng-template #readOnly>\r\n        {{ valueDate | date }}\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n</div>\r\n", styles: [".clear-date-icon{color:#999;font-size:15px}.input-container{position:relative}.input-container .form-control{padding:0 35px}.clear-date-btn{align-items:center;background:transparent;border:0px;position:absolute;right:10px;left:auto;top:50%;margin-top:-9px}.claendar-icon{border:none;background-color:transparent;position:absolute;display:flex;justify-content:flex-start;padding-inline-end:45px;width:100%;height:40px;align-items:center}.claendar-icon .icon{font-size:20px;color:#495057}.claendar-icon:focus{outline:none}.rtl .clear-date-btn{left:10px;right:auto}.rtl .owl-dt-container-info{direction:rtl}\n"], components: [{ type: i6.OwlDateTimeComponent, selector: "owl-date-time", inputs: ["backdropClass", "panelClass", "startAt", "pickerType", "pickerMode", "disabled", "opened", "scrollStrategy"], outputs: ["afterPickerClosed", "afterPickerOpen", "yearSelected", "monthSelected"], exportAs: ["owlDateTime"] }], directives: [{ type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.OwlDateTimeTriggerDirective, selector: "[owlDateTimeTrigger]", inputs: ["disabled", "owlDateTimeTrigger"] }, { type: i5.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i6.OwlDateTimeInputDirective, selector: "input[owlDateTime]", inputs: ["rangeSeparator", "value", "owlDateTime", "owlDateTimeFilter", "_disabled", "min", "max", "selectMode", "values"], outputs: ["dateTimeChange", "dateTimeInput"], exportAs: ["owlDateTimeInput"] }, { type: i5.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i7.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i8.MatError, selector: "mat-error", inputs: ["id"] }], pipes: { "translate": i4.TranslatePipe, "date": i7.DatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicFormDateItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        { provide: OWL_DATE_TIME_FORMATS, useValue: MY_MOMENT_FORMATS }
+                    ],
+                    selector: 'app-dynamic-form-dateitem',
+                    templateUrl: './dynamic-form-dateitem.component.html',
+                    styleUrls: ['./dynamic-form-dateitem.component.scss'],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormUpdateService }, { type: i2.DateAdapter }, { type: i3.UserPreferencesService }, { type: i4.TranslateService }, { type: i5.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { label: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], property: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], displayEmpty: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], startAt: [{
+                type: Input
+            }], displayClearAction: [{
+                type: Input
+            }], pickerType: [{
+                type: Input
+            }], selectMode: [{
+                type: Input
+            }], datepicker: [{
+                type: ViewChild,
+                args: ['datetimePicker']
+            }], isfilter: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-dateitem.component.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-dateitem/dynamic-form-dateitem.component.ts","../../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-form/components/dynamic-form-dateitem/dynamic-form-dateitem.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit, Optional, Self, ViewChild, ViewEncapsulation } from '@angular/core';\r\nimport { AbstractControl, ControlValueAccessor, NgControl } from '@angular/forms';\r\nimport { DateAdapter } from '@angular/material/core';\r\nimport { OWL_DATE_TIME_FORMATS } from '@busacca/ng-pick-datetime';\r\nimport { MatDatetimepicker } from '@mat-datetimepicker/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Moment } from 'moment';\r\nimport moment from 'moment-es6';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { UserPreferencesService, UserPreferenceValues } from '../../../../core/services/user/user-preferences.service';\r\nimport { MomentDateAdapter } from '../../../../core/utilities/moment-date-adapter';\r\nimport { DynamicFormDateItemModel } from '../../models/dynamic-form.models';\r\nimport { DynamicFormUpdateService } from '../../services/dynamic-form-update.service';\r\n\r\nexport const MY_MOMENT_FORMATS = {\r\n  parseInput: 'l LT',\r\n  fullPickerInput: 'l LT',\r\n  datePickerInput: 'l',\r\n  timePickerInput: 'LT',\r\n  monthYearLabel: 'MMM YYYY',\r\n  dateA11yLabel: 'LL',\r\n  monthYearA11yLabel: 'MMMM YYYY',\r\n};\r\n/** @ignore */\r\n@Component({\r\n  providers: [\r\n    { provide: OWL_DATE_TIME_FORMATS, useValue: MY_MOMENT_FORMATS }\r\n  ],\r\n  selector: 'app-dynamic-form-dateitem',\r\n  templateUrl: './dynamic-form-dateitem.component.html',\r\n  styleUrls: ['./dynamic-form-dateitem.component.scss'],\r\n  encapsulation: ViewEncapsulation.None\r\n\r\n})\r\nexport class DynamicFormDateItemComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n\r\n\r\n  @Input()\r\n  label;\r\n\r\n  @Input()\r\n  disabled = false;\r\n\r\n  inEdit = false;\r\n  editedValue: string;\r\n  errorMessages: string[];\r\n  valueSeparator: string;\r\n  @Input()\r\n  property: DynamicFormDateItemModel;\r\n\r\n  @Input()\r\n  editable: boolean = true;\r\n\r\n  @Input()\r\n  displayEmpty: boolean = true;\r\n\r\n  @Input()\r\n  min = null;\r\n  @Input()\r\n  max = null;\r\n  @Input()\r\n  startAt = null;\r\n\r\n  @Input()\r\n  displayClearAction: boolean = true;\r\n  @Input() pickerType: string = 'both';\r\n  @Input() selectMode: string = 'single';\r\n  @ViewChild('datetimePicker')\r\n  public datepicker: MatDatetimepicker<any>;\r\n\r\n  valueDate;\r\n  dateFormat: string;\r\n  @Input() isfilter= false; // showed error when building lib that this property is not exist \r\n  @Input() placeholder= ''; // showed error when building lib that this property is not exist \r\n\r\n  displayedTime = '';\r\n  private onDestroy$ = new Subject<boolean>();\r\n\r\n  constructor(\r\n    private dynamicFormUpdateService: DynamicFormUpdateService,\r\n    private dateAdapter: DateAdapter<Moment>,\r\n    private userPreferencesService: UserPreferencesService,\r\n    public translate: TranslateService,\r\n    @Self() @Optional() public control: NgControl\r\n\r\n  ) {\r\n    this.control.valueAccessor = this;\r\n    this.dateFormat = 'mediumDate';\r\n  }\r\n  onChange: any = () => { };\r\n  onTouched: any = () => { };\r\n\r\n  isRequired() {\r\n    if (!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  writeValue(obj: any): void {\r\n    if (this.selectMode === 'single') {\r\n      if(obj){\r\n        moment.locale('en-au');\r\n      this.valueDate = obj;\r\n        this.displayedTime = moment(obj).format(\"HH:mm\");\r\n      }else{\r\n        this.displayedTime = '';\r\n      }\r\n    } else {\r\n      this.valueDate = obj;\r\n    }\r\n\r\n    // this.property.value = obj;\r\n\r\n    //  throw new Error('Method not implemented.');\r\n  }\r\n  public get invalid(): boolean {\r\n    return this.control ? this.control.invalid : false;\r\n  }\r\n\r\n  public get showError(): boolean {\r\n    if (!this.control) {\r\n      return false;\r\n    }\r\n\r\n    const { dirty, touched } = this.control;\r\n\r\n    return this.invalid ? (dirty || touched) : false;\r\n  }\r\n  registerOnChange(fn: any) {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any) {\r\n    this.onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n  }\r\n\r\n  hasErrors(): boolean {\r\n    return this.showError;\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.userPreferencesService\r\n      .select(UserPreferenceValues.Locale)\r\n      .pipe(takeUntil(this.onDestroy$))\r\n      .subscribe(locale => {\r\n        // this.dateAdapter.setLocale(locale);\r\n        // this.property.locale = locale;\r\n      });\r\n\r\n    (<MomentDateAdapter>this.dateAdapter).overrideDisplayFormat = 'DD/MM/YYYY';\r\n\r\n    /* if (this.property.value) {\r\n       this.valueDate = moment(this.property.value);\r\n     } */\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.onDestroy$.next(true);\r\n    this.onDestroy$.complete();\r\n  }\r\n\r\n  showProperty(): boolean {\r\n    return this.displayEmpty || !this.property.isEmpty();\r\n  }\r\n\r\n  showClearAction(): boolean {\r\n    return (\r\n      this.displayClearAction &&\r\n      (!this.property.isEmpty() || !!this.property.default)\r\n    );\r\n  }\r\n\r\n  isEditable(): boolean {\r\n    return this.editable;\r\n  }\r\n  isDisabled(): boolean {\r\n    return this.disabled;\r\n  }\r\n  showDatePicker() {\r\n    this.datepicker.open();\r\n  }\r\n\r\n  onDateChanged(newDateValue) {\r\n    if (this.valueDate) {\r\n      if (this.selectMode === 'single') {\r\n        moment.locale('en-au');\r\n        const momentDate = moment(this.valueDate, this.dateFormat, true);\r\n        if (momentDate.isValid()) {\r\n          //this.property.value = momentDate.toDate();\r\n          this.onChange(momentDate.toDate());\r\n          this.onTouched();\r\n          // this.dynamicFormUpdateService.update(this.property, momentDate.toDate());\r\n        }\r\n        this.displayedTime = moment(this.valueDate).format(\"HH:mm\");\r\n      } else {\r\n        this.onChange(this.valueDate);\r\n        this.onTouched();\r\n      }\r\n\r\n    } else {\r\n      this.onChange(null);\r\n      this.onTouched();\r\n    }\r\n  }\r\n\r\n  onDateClear() {\r\n    this.valueDate = null;\r\n    this.onChange(this.valueDate);\r\n    this.onTouched();\r\n    this.displayedTime = '';\r\n    // this.dynamicFormUpdateService.update(this.property, null);\r\n    //this.property.value = null;\r\n    this.property ? this.property.default = null : '';\r\n  }\r\n}\r\n","<div class=\"app-property-value\">\r\n  <div class=\"app-input-wrapper\">\r\n    <ng-container *ngIf=\"label\">\r\n      <label class=\"\" for=\"formGroupInputSmall\"\r\n        >{{ label | translate\r\n        }}<span *ngIf=\"isRequired()\" class=\"text-danger m-1\">*</span>\r\n      </label>\r\n    </ng-container>\r\n    <div class=\"input-container\">\r\n      <ng-container *ngIf=\"isEditable(); else readOnly\">\r\n\r\n        <button *ngIf=\"!isfilter && pickerType !== 'timer'\" type=\"button\" class=\"claendar-icon\" [owlDateTimeTrigger]=\"dt3\">\r\n          <i class=\"bi bi-calendar-week icon\"></i>        </button>\r\n\r\n          <button *ngIf=\"!isfilter && pickerType === 'timer'\" type=\"button\" class=\"claendar-icon\" [owlDateTimeTrigger]=\"dt3\">\r\n            <i class=\"bi bi-clock icon\"></i>        </button>\r\n        <input\r\n          class=\"form-control date\"\r\n          [disabled]=\"isDisabled() || null\"\r\n          (blur)=\"onTouched($event)\"\r\n          [min]=\"min\"\r\n          [max]=\"max\"\r\n          [selectMode]=\"selectMode\"\r\n          [required]=\"isRequired\"\r\n          [(ngModel)]=\"valueDate\"\r\n          (ngModelChange)=\"onDateChanged($event)\"\r\n          autocomplete=\"false\"\r\n          [owlDateTimeTrigger]=\"dt3\"\r\n          [owlDateTime]=\"dt3\"\r\n          placeholder=\"{{ placeholder }}\"\r\n        />\r\n        <input\r\n        class=\"form-control timer\"\r\n        [disabled]=\"true\"\r\n        [required]=\"isRequired\"\r\n        [(ngModel)]=\"displayedTime\"\r\n        placeholder=\"{{ placeholder }}\"\r\n      />\r\n\r\n        <button type=\"button\" *ngIf=\"valueDate\" (click)=\"onDateClear()\" class=\"relative mx-1 clear-date-btn\"\r\n        [ngClass]=\"{'d-none': isDisabled()}\">\r\n          <i class=\"clear-date-icon material-icons  flex mr-1\">&#xE14C;</i>\r\n        </button>\r\n        <owl-date-time\r\n          [startAt]=\"startAt\"\r\n          [pickerType]=\"pickerType\"\r\n          #dt3\r\n        ></owl-date-time>\r\n\r\n        <mat-error\r\n          [attr.data-automation-id]=\"'card-textitem-error-'\"\r\n          class=\"app-textitem-editable-error\"\r\n          *ngIf=\"hasErrors()\"\r\n        >\r\n          <ul>\r\n            <li *ngIf=\"control.errors.required\">\r\n             <span *ngIf=\"label\" class=\"mx-1\">{{ label | translate}}</span> {{ \"VALIDATORS.REQUIRED\" | translate }}\r\n            </li>\r\n          </ul>\r\n        </mat-error>\r\n      </ng-container>\r\n      <ng-template #readOnly>\r\n        {{ valueDate | date }}\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n</div>\r\n"]}

package/esm2015/lib/components/dynamic-form/components/dynamic-form-dateitem/owlDateTimeIntl.js

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { OwlDateTimeIntl } from '@busacca/ng-pick-datetime';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../../../../core/services/user/user-preferences.service";
+import * as i3 from "@busacca/ng-pick-datetime";
+export class owlDateTimeIntl extends OwlDateTimeIntl {
+    constructor(translate, userPreference, dateTimeAdapter) {
+        super();
+        this.translate = translate;
+        this.userPreference = userPreference;
+        this.dateTimeAdapter = dateTimeAdapter;
+        this.cancelBtnLabel = 'Cancel';
+        this.setBtnLabel = 'Set';
+        /** A label for the up second button (used by screen readers).  */
+        this.upSecondLabel = 'Add a second';
+        /** A label for the down second button (used by screen readers).  */
+        this.downSecondLabel = 'Minus a second';
+        /** A label for the up minute button (used by screen readers).  */
+        this.upMinuteLabel = 'Add a minute';
+        /** A label for the down minute button (used by screen readers).  */
+        this.downMinuteLabel = 'Minus a minute';
+        /** A label for the up hour button (used by screen readers).  */
+        this.upHourLabel = 'Add a hour';
+        /** A label for the down hour button (used by screen readers).  */
+        this.downHourLabel = 'Minus a hour';
+        /** A label for the previous month button (used by screen readers). */
+        this.prevMonthLabel = 'Previous month';
+        /** A label for the next month button (used by screen readers). */
+        this.nextMonthLabel = 'Next month';
+        /** A label for the previous year button (used by screen readers). */
+        this.prevYearLabel = 'Previous year';
+        /** A label for the next year button (used by screen readers). */
+        this.nextYearLabel = 'Next year';
+        /** A label for the previous multi-year button (used by screen readers). */
+        this.prevMultiYearLabel = 'Previous 21 years';
+        /** A label for the next multi-year button (used by screen readers). */
+        this.nextMultiYearLabel = 'Next 21 years';
+        /** A label for the 'switch to month view' button (used by screen readers). */
+        this.switchToMonthViewLabel = 'Change to month view';
+        /** A label for the 'switch to year view' button (used by screen readers). */
+        this.switchToMultiYearViewLabel = 'Choose month and year';
+        /** A label for the range 'from' in picker info */
+        this.rangeFromLabel = 'From';
+        /** A label for the range 'to' in picker info */
+        this.rangeToLabel = 'To';
+        /** A label for the hour12 button (AM) */
+        this.hour12AMLabel = 'AM';
+        /** A label for the hour12 button (PM) */
+        this.hour12PMLabel = 'PM';
+        this.getLang();
+        this.translate.onLangChange.subscribe((lang) => {
+            this.getLang();
+        });
+    }
+    getLang() {
+        this.currentLang = this.userPreference.locale;
+        this.dateTimeAdapter.setLocale(this.currentLang);
+        const properties = Object.getOwnPropertyNames(this);
+        properties.forEach((property) => {
+            if (typeof this[property] !== 'string') {
+                return;
+            }
+            this.translate.get('DATETIME_OWL.' + property).subscribe((text) => {
+                this[property] = text;
+            });
+        });
+    }
+}
+owlDateTimeIntl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: owlDateTimeIntl, deps: [{ token: i1.TranslateService }, { token: i2.UserPreferencesService }, { token: i3.DateTimeAdapter }], target: i0.ɵɵFactoryTarget.Injectable });
+owlDateTimeIntl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: owlDateTimeIntl, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: owlDateTimeIntl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.UserPreferencesService }, { type: i3.DateTimeAdapter }]; } });
+//# sourceMappingURL=data:application/json;base64,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