@esfaenza/forms-and-validations 12.2.28 → 13.1.3

package/esm2020/lib/forms-and-validations.module.mjs

@@ -0,0 +1,203 @@
+// Angular
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatInputModule } from "@angular/material/input";
+import { MAT_DATE_LOCALE, MAT_DATE_FORMATS } from "@angular/material/core";
+// Es
+import { LocalizationModule } from "@esfaenza/localizations";
+import { MatDayjsDateModule } from '@esfaenza/material-dayjs-adapter';
+import { CurrencyMaskModule } from '@esfaenza/ngx-currency-mask';
+// Librerie / Modelli
+import { AngularMultiSelectModule } from "angular2-multiselect-dropdown";
+import { NgxMatDateAdapter, NgxMatDatetimePickerModule, NGX_MAT_DATE_FORMATS, NgxMatTimepickerModule } from '@angular-material-components/datetime-picker';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+import { FAV_LOCALE, ACO_CUSTOMKEY } from './tokens';
+import { CustomRequiredDirective } from './validations/customValidators/CustomRequiredDirective';
+import { NgxExpandedDayJsDateAdapter } from './models/dayjs-adapter/dayjs-date-adapter';
+// Validations
+import { ValidationSelectComponent } from './validations/validation-select/validation-select.component';
+import { ValidationDateComponent } from './validations/validation-date/validation-date.component';
+import { ValidationCurrencyComponent } from './validations/validation-currency/validation-currency.component';
+import { ValidationTextAreaComponent } from './validations/validation-text-area/validation-text-area.component';
+import { ValidationInputComponent } from './validations/validation-input/validation-input.component';
+import { ValidationDateTimeComponent } from './validations/validation-datetime/validation-datetime.component';
+import { ValidationAutocompleteComponent } from './validations/validation-autocomplete/validation-autocomplete.component';
+// Forms
+import { FormFileComponent } from './forms/form-file/form-file.component';
+import { FormDateTimeComponent } from './forms/form-datetime/form-datetime.component';
+import { FormAdaptiveComponent } from './forms/form-adaptive/form-adaptive.component';
+import { FormEmptyComponent } from './forms/form-empty/form-empty.component';
+import { FormTemplateComponent } from './forms/form-template/form-template.component';
+import { FormErrorComponent } from './forms/form-error/form-error.component';
+import { FormInfoComponent } from './forms/form-info/form-info.component';
+import { FormCheckboxComponent } from './forms/form-checkbox/form-checkbox.component';
+import { FormDateComponent } from './forms/form-date/form-date.component';
+import { FormInputComponent } from './forms/form-input/form-input.component';
+import { FormSelectComponent } from './forms/form-select/form-select.component';
+import { FormMultiSelectComponent } from './forms/form-multiselect/form-multiselect.component';
+import { FormTextareaComponent } from './forms/form-textarea/form-textarea.component';
+import { FormAutocompleteComponent } from './forms/form-autocomplete/form-autocomplete.component';
+import { FormTimeComponent } from './forms/form-time/form-time.component';
+import * as i0 from "@angular/core";
+/**
+ * Formato in display (modalità breve, senza ore, minuti e secondi) delle date per tutti i componenti che utilizzino input data.
+ *
+ * Da convenzione è sempre quello italiano quindi viene cablato
+ */
+const formats = {
+    parse: { dateInput: 'DD/MM/YYYY' },
+    display: {
+        dateInput: 'DD/MM/YYYY',
+        monthYearLabel: 'MM YYYY',
+        dateA11yLabel: 'DD/MM/YYYY',
+        monthYearA11yLabel: 'MM YYYY',
+    }
+};
+/**
+ * Formato in display (modalità lunga, con ore, minuti e secondi) delle date per tutti i componenti che utilizzino input data.
+ *
+ * Da convenzione è sempre quello italiano quindi viene cablato
+ */
+const formats_long = {
+    parse: { dateInput: 'DD/MM/YYYY HH:mm:ss' },
+    display: {
+        dateInput: 'DD/MM/YYYY HH:mm:ss',
+        monthYearLabel: 'MM YYYY',
+        dateA11yLabel: 'DD/MM/YYYY HH:mm:ss',
+        monthYearA11yLabel: 'MM YYYY',
+    }
+};
+/**
+ * Componenti Dichiarati ed esportati dalla libreria
+ */
+const COMPONENTS = [
+    ValidationInputComponent,
+    ValidationSelectComponent,
+    ValidationDateComponent,
+    CustomRequiredDirective,
+    ValidationCurrencyComponent,
+    ValidationTextAreaComponent,
+    FormCheckboxComponent,
+    FormDateComponent,
+    FormEmptyComponent,
+    FormInputComponent,
+    FormSelectComponent,
+    FormTextareaComponent,
+    FormTemplateComponent,
+    FormErrorComponent,
+    FormInfoComponent,
+    FormAdaptiveComponent,
+    FormMultiSelectComponent,
+    FormFileComponent,
+    ValidationAutocompleteComponent,
+    FormAutocompleteComponent,
+    FormDateTimeComponent,
+    ValidationDateTimeComponent,
+    FormTimeComponent
+];
+/**
+ * Moduli utilizzati solo dalla libreria
+ */
+const MODULES = [
+    CommonModule,
+    FormsModule,
+    LocalizationModule,
+    MatInputModule,
+    MatDatepickerModule,
+    MatDayjsDateModule,
+    TooltipModule,
+    CurrencyMaskModule,
+    MatAutocompleteModule,
+    NgxMatDatetimePickerModule,
+    NgxMatTimepickerModule
+];
+/**
+ * Moduli utilizzati dalla libreria e che devono essere esposti all'esterno
+ */
+const MODULES_TO_EXPORT = [
+    AngularMultiSelectModule
+];
+export class FormsAndValidationsModule {
+    static forRoot(config) {
+        return {
+            ngModule: FormsAndValidationsModule,
+            providers: [
+                { provide: FAV_LOCALE, useValue: config?.locale || 'it-IT' },
+                { provide: ACO_CUSTOMKEY, useValue: config?.acocustom || null },
+                { provide: MAT_DATE_LOCALE, useValue: 'it' },
+                { provide: MAT_DATE_FORMATS, useValue: formats },
+                { provide: NGX_MAT_DATE_FORMATS, useValue: formats_long },
+                { provide: NgxMatDateAdapter, useClass: NgxExpandedDayJsDateAdapter },
+            ]
+        };
+    }
+}
+FormsAndValidationsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormsAndValidationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FormsAndValidationsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormsAndValidationsModule, declarations: [ValidationInputComponent,
+        ValidationSelectComponent,
+        ValidationDateComponent,
+        CustomRequiredDirective,
+        ValidationCurrencyComponent,
+        ValidationTextAreaComponent,
+        FormCheckboxComponent,
+        FormDateComponent,
+        FormEmptyComponent,
+        FormInputComponent,
+        FormSelectComponent,
+        FormTextareaComponent,
+        FormTemplateComponent,
+        FormErrorComponent,
+        FormInfoComponent,
+        FormAdaptiveComponent,
+        FormMultiSelectComponent,
+        FormFileComponent,
+        ValidationAutocompleteComponent,
+        FormAutocompleteComponent,
+        FormDateTimeComponent,
+        ValidationDateTimeComponent,
+        FormTimeComponent], imports: [CommonModule,
+        FormsModule,
+        LocalizationModule,
+        MatInputModule,
+        MatDatepickerModule,
+        MatDayjsDateModule,
+        TooltipModule,
+        CurrencyMaskModule,
+        MatAutocompleteModule,
+        NgxMatDatetimePickerModule,
+        NgxMatTimepickerModule, AngularMultiSelectModule], exports: [AngularMultiSelectModule, ValidationInputComponent,
+        ValidationSelectComponent,
+        ValidationDateComponent,
+        CustomRequiredDirective,
+        ValidationCurrencyComponent,
+        ValidationTextAreaComponent,
+        FormCheckboxComponent,
+        FormDateComponent,
+        FormEmptyComponent,
+        FormInputComponent,
+        FormSelectComponent,
+        FormTextareaComponent,
+        FormTemplateComponent,
+        FormErrorComponent,
+        FormInfoComponent,
+        FormAdaptiveComponent,
+        FormMultiSelectComponent,
+        FormFileComponent,
+        ValidationAutocompleteComponent,
+        FormAutocompleteComponent,
+        FormDateTimeComponent,
+        ValidationDateTimeComponent,
+        FormTimeComponent] });
+FormsAndValidationsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormsAndValidationsModule, imports: [[...MODULES, ...MODULES_TO_EXPORT], AngularMultiSelectModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FormsAndValidationsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...MODULES, ...MODULES_TO_EXPORT],
+                    declarations: [...COMPONENTS],
+                    exports: [...MODULES_TO_EXPORT, ...COMPONENTS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forms-and-validations.module.js","sourceRoot":"","sources":["../../../../projects/forms-and-validations/src/lib/forms-and-validations.module.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { ModuleWithProviders, NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatInputModule } from \"@angular/material/input\";\r\nimport { MAT_DATE_LOCALE, MAT_DATE_FORMATS } from \"@angular/material/core\";\r\n\r\n// Es\r\nimport { LocalizationModule } from \"@esfaenza/localizations\";\r\nimport { MatDayjsDateModule } from '@esfaenza/material-dayjs-adapter';\r\nimport { CurrencyMaskModule } from '@esfaenza/ngx-currency-mask';\r\n\r\n// Librerie / Modelli\r\nimport { AngularMultiSelectModule } from \"angular2-multiselect-dropdown\";\r\nimport { NgxMatDateAdapter, NgxMatDatetimePickerModule, NGX_MAT_DATE_FORMATS, NgxMatTimepickerModule } from '@angular-material-components/datetime-picker';\r\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\r\n\r\nimport { FAV_LOCALE, ACO_CUSTOMKEY } from './tokens';\r\nimport { FormsAndValidationsModuleConfig } from './models/FormsAndValidationsModuleConfig';\r\nimport { CustomRequiredDirective } from './validations/customValidators/CustomRequiredDirective';\r\nimport { NgxExpandedDayJsDateAdapter } from './models/dayjs-adapter/dayjs-date-adapter';\r\n\r\n// Validations\r\nimport { ValidationSelectComponent } from './validations/validation-select/validation-select.component';\r\nimport { ValidationDateComponent } from './validations/validation-date/validation-date.component';\r\nimport { ValidationCurrencyComponent } from './validations/validation-currency/validation-currency.component';\r\nimport { ValidationTextAreaComponent } from './validations/validation-text-area/validation-text-area.component';\r\nimport { ValidationInputComponent } from './validations/validation-input/validation-input.component';\r\nimport { ValidationDateTimeComponent } from './validations/validation-datetime/validation-datetime.component';\r\nimport { ValidationAutocompleteComponent } from './validations/validation-autocomplete/validation-autocomplete.component';\r\n\r\n// Forms\r\nimport { FormFileComponent } from './forms/form-file/form-file.component';\r\nimport { FormDateTimeComponent } from './forms/form-datetime/form-datetime.component';\r\nimport { FormAdaptiveComponent } from './forms/form-adaptive/form-adaptive.component';\r\nimport { FormEmptyComponent } from './forms/form-empty/form-empty.component';\r\nimport { FormTemplateComponent } from './forms/form-template/form-template.component';\r\nimport { FormErrorComponent } from './forms/form-error/form-error.component';\r\nimport { FormInfoComponent } from './forms/form-info/form-info.component';\r\nimport { FormCheckboxComponent } from './forms/form-checkbox/form-checkbox.component';\r\nimport { FormDateComponent } from './forms/form-date/form-date.component';\r\nimport { FormInputComponent } from './forms/form-input/form-input.component';\r\nimport { FormSelectComponent } from './forms/form-select/form-select.component';\r\nimport { FormMultiSelectComponent } from './forms/form-multiselect/form-multiselect.component';\r\nimport { FormTextareaComponent } from './forms/form-textarea/form-textarea.component';\r\nimport { FormAutocompleteComponent } from './forms/form-autocomplete/form-autocomplete.component';\r\nimport { FormTimeComponent } from './forms/form-time/form-time.component';\r\n\r\n/**\r\n * Formato in display (modalità breve, senza ore, minuti e secondi) delle date per tutti i componenti che utilizzino input data.\r\n * \r\n * Da convenzione è sempre quello italiano quindi viene cablato\r\n */\r\nconst formats = {\r\n  parse: { dateInput: 'DD/MM/YYYY' },\r\n  display: {\r\n    dateInput: 'DD/MM/YYYY',\r\n    monthYearLabel: 'MM YYYY',\r\n    dateA11yLabel: 'DD/MM/YYYY',\r\n    monthYearA11yLabel: 'MM YYYY',\r\n  }\r\n};\r\n\r\n/**\r\n * Formato in display (modalità lunga, con ore, minuti e secondi) delle date per tutti i componenti che utilizzino input data.\r\n * \r\n * Da convenzione è sempre quello italiano quindi viene cablato\r\n */\r\nconst formats_long = {\r\n  parse: { dateInput: 'DD/MM/YYYY HH:mm:ss' },\r\n  display: {\r\n    dateInput: 'DD/MM/YYYY HH:mm:ss',\r\n    monthYearLabel: 'MM YYYY',\r\n    dateA11yLabel: 'DD/MM/YYYY HH:mm:ss',\r\n    monthYearA11yLabel: 'MM YYYY',\r\n  }\r\n};\r\n\r\n/**\r\n * Componenti Dichiarati ed esportati dalla libreria\r\n */\r\nconst COMPONENTS = [\r\n  ValidationInputComponent,\r\n  ValidationSelectComponent,\r\n  ValidationDateComponent,\r\n  CustomRequiredDirective,\r\n  ValidationCurrencyComponent,\r\n  ValidationTextAreaComponent,\r\n  FormCheckboxComponent,\r\n  FormDateComponent,\r\n  FormEmptyComponent,\r\n  FormInputComponent,\r\n  FormSelectComponent,\r\n  FormTextareaComponent,\r\n  FormTemplateComponent,\r\n  FormErrorComponent,\r\n  FormInfoComponent,\r\n  FormAdaptiveComponent,\r\n  FormMultiSelectComponent,\r\n  FormFileComponent,\r\n  ValidationAutocompleteComponent,\r\n  FormAutocompleteComponent,\r\n  FormDateTimeComponent,\r\n  ValidationDateTimeComponent,\r\n  FormTimeComponent\r\n];\r\n\r\n/**\r\n * Moduli utilizzati solo dalla libreria\r\n */\r\nconst MODULES = [\r\n  CommonModule,\r\n  FormsModule,\r\n  LocalizationModule,\r\n  MatInputModule,\r\n  MatDatepickerModule,\r\n  MatDayjsDateModule,\r\n  TooltipModule,\r\n  CurrencyMaskModule,\r\n  MatAutocompleteModule,\r\n  NgxMatDatetimePickerModule,\r\n  NgxMatTimepickerModule\r\n];\r\n\r\n/**\r\n * Moduli utilizzati dalla libreria e che devono essere esposti all'esterno\r\n */\r\nconst MODULES_TO_EXPORT = [\r\n  AngularMultiSelectModule\r\n];\r\n\r\n@NgModule({\r\n  imports: [...MODULES, ...MODULES_TO_EXPORT],\r\n  declarations: [...COMPONENTS],\r\n  exports: [...MODULES_TO_EXPORT, ...COMPONENTS]\r\n})\r\nexport class FormsAndValidationsModule {\r\n  static forRoot(config?: FormsAndValidationsModuleConfig): ModuleWithProviders<FormsAndValidationsModule> {\r\n    return {\r\n      ngModule: FormsAndValidationsModule,\r\n      providers: [\r\n        { provide: FAV_LOCALE, useValue: config?.locale || 'it-IT' },\r\n        { provide: ACO_CUSTOMKEY, useValue: config?.acocustom || null },\r\n        { provide: MAT_DATE_LOCALE, useValue: 'it' },\r\n        { provide: MAT_DATE_FORMATS, useValue: formats },\r\n        { provide: NGX_MAT_DATE_FORMATS, useValue: formats_long },\r\n        { provide: NgxMatDateAdapter, useClass: NgxExpandedDayJsDateAdapter },\r\n      ]\r\n    };\r\n  }\r\n}"]}

package/esm2020/lib/models/dayjs-adapter/dayjs-date-adapter.mjs

@@ -0,0 +1,89 @@
+//Angular
+import { Inject, Injectable } from "@angular/core";
+import { MAT_DATE_LOCALE } from "@angular/material/core";
+//Libreria
+// Questa non è più usata, la tengo qui per crosscheck in caso di updates
+//import { NgxMatDateAdapter } from "@angular-material-components/datetime-picker";
+import { DayJsDateAdapter } from "@esfaenza/material-dayjs-adapter";
+import * as i0 from "@angular/core";
+/**
+ * Espansione dell'adapter di default di DayJs già utilizzato per i bind base su Material.
+ *
+ * Questa versione serve unicamente per i controlli **datetime-picker**, ma dato che io l'adapter già lo avevo lato **esfaenza/material-dayjs-adapter**
+ * qui devo semplicemente aggiungere le funzioni non presenti nella mia implementazione che servono al **datetime-picker**
+ */
+export class NgxExpandedDayJsDateAdapter extends DayJsDateAdapter {
+    /**
+     * @ignore
+     */
+    constructor(dateLocale) {
+        super(dateLocale);
+    }
+    // Espando il mio DayJsDateAdapter con i metodi extra del NgxMatDateAdapter che servono per il material timepicker
+    // Non potendo fare "extends" da due classi mi tocca tenerlo così senza type safety.... 
+    /**
+     * Identifica se due date hanno lo stesso orario
+     *
+     * @param {DayJs} a Primo elemento del controllo
+     * @param {DayJs} b Secondo elemento del controllo
+     * @returns **true** se hanno lo stess orario, **false** altrimenti
+     */
+    isSameTime(a, b) {
+        if (a == null || b == null)
+            return true;
+        return this.getHour(a) === this.getHour(b)
+            && this.getMinute(a) === this.getMinute(b)
+            && this.getSecond(a) === this.getSecond(b);
+    }
+    /**
+     * Copia dell'orario da una data all'altra, Modifica direttamente l'oggetto **toDate**
+     *
+     * @param {DayJs} toDate Data in cui copiare l'orario
+     * @param {DayJs} fromDate Data da cui copiare l'orario
+     */
+    copyTime(toDate, fromDate) {
+        this.setHour(toDate, this.getHour(fromDate));
+        this.setMinute(toDate, this.getMinute(fromDate));
+        this.setSecond(toDate, this.getSecond(fromDate));
+    }
+    /**
+     * Mette a confronto due date
+     * @param {Dayjs} first Prima data da confrontare
+     * @param {Dayjs} second Seconda data da confrontare
+     * @param {boolean} showSeconds Indica se considerare anche i secondi, di default no
+     * @returns {number} 0 se le due date sono uguali, un numero minore di 0 se la prima data è precedente alla seconda e un numero maggiore di 0 altrimenti
+     */
+    compareDateWithTime(first, second, showSeconds) {
+        let res = super.compareDate(first, second) ||
+            this.getHour(first) - this.getHour(second) ||
+            this.getMinute(first) - this.getMinute(second);
+        if (showSeconds)
+            res = res || this.getSecond(first) - this.getSecond(second);
+        return res;
+    }
+    /**
+     * Assegna a una data i valori di ore, minuti e secondi di default.
+     *
+     * Se non specificati vengono assegnati degli '0'
+     *
+     * @param {DayJs} date Data a cui assegnare i valori di default
+     * @param {number[]} defaultTime Valori di default per ore, minuti e secondi, considerati 0 se non presenti
+     */
+    setTimeByDefaultValues(date, defaultTime) {
+        if (!Array.isArray(defaultTime)) {
+            throw Error('@Input DefaultTime should be an array');
+        }
+        this.setHour(date, defaultTime[0] || 0);
+        this.setMinute(date, defaultTime[1] || 0);
+        this.setSecond(date, defaultTime[2] || 0);
+    }
+}
+NgxExpandedDayJsDateAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxExpandedDayJsDateAdapter, deps: [{ token: MAT_DATE_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable });
+NgxExpandedDayJsDateAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxExpandedDayJsDateAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: NgxExpandedDayJsDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dayjs-date-adapter.js","sourceRoot":"","sources":["../../../../../../projects/forms-and-validations/src/lib/models/dayjs-adapter/dayjs-date-adapter.ts"],"names":[],"mappings":"AAAA,SAAS;AACT,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAoB,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE3E,UAAU;AACV,yEAAyE;AACzE,mFAAmF;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;;AAGpE;;;;;GAKG;AAEH,MAAM,OAAO,2BAA4B,SAAQ,gBAAgB;IAE7D;;OAEG;IACH,YAAqC,UAAkB;QACnD,KAAK,CAAC,UAAU,CAAC,CAAC;IACtB,CAAC;IAED,kHAAkH;IAClH,wFAAwF;IAExF;;;;;;OAMG;IACH,UAAU,CAAC,CAAQ,EAAE,CAAQ;QACzB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;QACxC,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;eACnC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;eACvC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,MAAa,EAAE,QAAe;QACnC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,KAAY,EAAE,MAAa,EAAE,WAAqB;QAClE,IAAI,GAAG,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC;YACtC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;YAC1C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAEnD,IAAI,WAAW;YACX,GAAG,GAAG,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAEhE,OAAO,GAAG,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAW,EAAE,WAAqB;QACrD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YAC7B,MAAM,KAAK,CAAC,uCAAuC,CAAC,CAAC;SACxD;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,CAAC;;wHAvEQ,2BAA2B,kBAKhB,eAAe;4HAL1B,2BAA2B;2FAA3B,2BAA2B;kBADvC,UAAU;;0BAMM,MAAM;2BAAC,eAAe","sourcesContent":["//Angular\r\nimport { Inject, Injectable } from \"@angular/core\";\r\nimport { MAT_DATE_FORMATS, MAT_DATE_LOCALE } from \"@angular/material/core\";\r\n\r\n//Libreria\r\n// Questa non è più usata, la tengo qui per crosscheck in caso di updates\r\n//import { NgxMatDateAdapter } from \"@angular-material-components/datetime-picker\";\r\nimport { DayJsDateAdapter } from \"@esfaenza/material-dayjs-adapter\";\r\nimport { Dayjs } from \"dayjs\";\r\n\r\n/**\r\n * Espansione dell'adapter di default di DayJs già utilizzato per i bind base su Material.\r\n * \r\n * Questa versione serve unicamente per i controlli **datetime-picker**, ma dato che io l'adapter già lo avevo lato **esfaenza/material-dayjs-adapter** \r\n * qui devo semplicemente aggiungere le funzioni non presenti nella mia implementazione che servono al **datetime-picker**\r\n */\r\n@Injectable()\r\nexport class NgxExpandedDayJsDateAdapter extends DayJsDateAdapter {\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    constructor(@Inject(MAT_DATE_LOCALE) dateLocale: string) {\r\n        super(dateLocale);\r\n    }\r\n\r\n    // Espando il mio DayJsDateAdapter con i metodi extra del NgxMatDateAdapter che servono per il material timepicker\r\n    // Non potendo fare \"extends\" da due classi mi tocca tenerlo così senza type safety.... \r\n\r\n    /**\r\n     * Identifica se due date hanno lo stesso orario\r\n     * \r\n     * @param {DayJs} a Primo elemento del controllo\r\n     * @param {DayJs} b Secondo elemento del controllo\r\n     * @returns **true** se hanno lo stess orario, **false** altrimenti\r\n     */\r\n    isSameTime(a: Dayjs, b: Dayjs): boolean {\r\n        if (a == null || b == null) return true;\r\n        return this.getHour(a) === this.getHour(b)\r\n            && this.getMinute(a) === this.getMinute(b)\r\n            && this.getSecond(a) === this.getSecond(b);\r\n    }\r\n\r\n    /**\r\n     * Copia dell'orario da una data all'altra, Modifica direttamente l'oggetto **toDate**\r\n     * \r\n     * @param {DayJs} toDate Data in cui copiare l'orario\r\n     * @param {DayJs} fromDate Data da cui copiare l'orario\r\n     */\r\n    copyTime(toDate: Dayjs, fromDate: Dayjs) {\r\n        this.setHour(toDate, this.getHour(fromDate));\r\n        this.setMinute(toDate, this.getMinute(fromDate));\r\n        this.setSecond(toDate, this.getSecond(fromDate));\r\n    }\r\n\r\n    /**\r\n     * Mette a confronto due date\r\n     * @param {Dayjs} first Prima data da confrontare\r\n     * @param {Dayjs} second Seconda data da confrontare\r\n     * @param {boolean} showSeconds Indica se considerare anche i secondi, di default no\r\n     * @returns {number} 0 se le due date sono uguali, un numero minore di 0 se la prima data è precedente alla seconda e un numero maggiore di 0 altrimenti\r\n     */\r\n    compareDateWithTime(first: Dayjs, second: Dayjs, showSeconds?: boolean): number {\r\n        let res = super.compareDate(first, second) ||\r\n            this.getHour(first) - this.getHour(second) ||\r\n            this.getMinute(first) - this.getMinute(second);\r\n\r\n        if (showSeconds)\r\n            res = res || this.getSecond(first) - this.getSecond(second);\r\n            \r\n        return res;\r\n    }\r\n\r\n    /**\r\n     * Assegna a una data i valori di ore, minuti e secondi di default. \r\n     * \r\n     * Se non specificati vengono assegnati degli '0'\r\n     * \r\n     * @param {DayJs} date Data a cui assegnare i valori di default\r\n     * @param {number[]} defaultTime Valori di default per ore, minuti e secondi, considerati 0 se non presenti\r\n     */\r\n    setTimeByDefaultValues(date: Dayjs, defaultTime: number[]) {\r\n        if (!Array.isArray(defaultTime)) {\r\n            throw Error('@Input DefaultTime should be an array');\r\n        }\r\n        this.setHour(date, defaultTime[0] || 0);\r\n        this.setMinute(date, defaultTime[1] || 0);\r\n        this.setSecond(date, defaultTime[2] || 0);\r\n    }\r\n}"]}

package/esm2020/lib/validations/base-validation.loc.mjs

@@ -0,0 +1,28 @@
+import { Injectable, Inject, Optional } from "@angular/core";
+import { LocalizationService } from "@esfaenza/localizations";
+import { FAV_LOCALE } from '../tokens';
+import * as i0 from "@angular/core";
+/**
+ * Classe di localizzazione in comune con tutti i Componenti di validazione
+ */
+export class BaseValidationLoc extends LocalizationService {
+    /**
+     * @ignore
+     */
+    constructor(LOC_LOCALE) {
+        super(LOC_LOCALE ?? 'it-IT');
+        super.set("en->it", "Required Input", ["Input Richiesto"]);
+        super.set("en->it", "Invalid Input Format", ["Formato Input Invalido"]);
+    }
+}
+BaseValidationLoc.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseValidationLoc, deps: [{ token: FAV_LOCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseValidationLoc.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseValidationLoc });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseValidationLoc, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FAV_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS12YWxpZGF0aW9uLmxvYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Zvcm1zLWFuZC12YWxpZGF0aW9ucy9zcmMvbGliL3ZhbGlkYXRpb25zL2Jhc2UtdmFsaWRhdGlvbi5sb2MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzdELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxXQUFXLENBQUM7O0FBRXZDOztHQUVHO0FBRUgsTUFBTSxPQUFPLGlCQUFrQixTQUFRLG1CQUFtQjtJQUV0RDs7T0FFRztJQUNILFlBQTZDLFVBQWtCO1FBQzNELEtBQUssQ0FBQyxVQUFVLElBQUksT0FBTyxDQUFDLENBQUM7UUFDN0IsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUM7UUFDM0QsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDLENBQUM7SUFDNUUsQ0FBQzs7OEdBVFEsaUJBQWlCLGtCQUtPLFVBQVU7a0hBTGxDLGlCQUFpQjsyRkFBakIsaUJBQWlCO2tCQUQ3QixVQUFVOzswQkFNTSxRQUFROzswQkFBSyxNQUFNOzJCQUFDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBJbmplY3QsIE9wdGlvbmFsIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgTG9jYWxpemF0aW9uU2VydmljZSB9IGZyb20gXCJAZXNmYWVuemEvbG9jYWxpemF0aW9uc1wiO1xyXG5pbXBvcnQgeyBGQVZfTE9DQUxFIH0gZnJvbSAnLi4vdG9rZW5zJztcclxuXHJcbi8qKlxyXG4gKiBDbGFzc2UgZGkgbG9jYWxpenphemlvbmUgaW4gY29tdW5lIGNvbiB0dXR0aSBpIENvbXBvbmVudGkgZGkgdmFsaWRhemlvbmVcclxuICovXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIEJhc2VWYWxpZGF0aW9uTG9jIGV4dGVuZHMgTG9jYWxpemF0aW9uU2VydmljZSB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAaWdub3JlXHJcbiAgICAgKi9cclxuICAgIGNvbnN0cnVjdG9yKEBPcHRpb25hbCgpICBASW5qZWN0KEZBVl9MT0NBTEUpIExPQ19MT0NBTEU6IHN0cmluZykge1xyXG4gICAgICAgIHN1cGVyKExPQ19MT0NBTEUgPz8gJ2l0LUlUJyk7XHJcbiAgICAgICAgc3VwZXIuc2V0KFwiZW4tPml0XCIsIFwiUmVxdWlyZWQgSW5wdXRcIiwgW1wiSW5wdXQgUmljaGllc3RvXCJdKTtcclxuICAgICAgICBzdXBlci5zZXQoXCJlbi0+aXRcIiwgXCJJbnZhbGlkIElucHV0IEZvcm1hdFwiLCBbXCJGb3JtYXRvIElucHV0IEludmFsaWRvXCJdKTtcclxuICAgIH1cclxufSJdfQ==

package/esm2020/lib/validations/base-validation.mjs

@@ -0,0 +1,232 @@
+// Angular
+import { EventEmitter, Input, Output, ViewChild, Directive } from "@angular/core";
+// Direttive, Componenti, Librerie
+import { TooltipDirective } from "ngx-bootstrap/tooltip";
+import * as i0 from "@angular/core";
+/**
+ * Classe astratta base che contiene le logiche / proprietà in comune a tutti i validatori
+ *
+ * Nota bene: I tooltip rallentano tantissimo la pagina perché il tizio che ha fatto ngx bootstrap non è capace
+ */
+export class BaseValidation {
+    constructor() {
+        /**
+         * Variabile per tenere in memoria il fatto che il componente è forzato a invalido o no
+         */
+        this._forceInvalid = false;
+        /**
+         * Indica se il valore è obbligatorio o opzionale
+         */
+        this.required = false;
+        /**
+         * Indica se di default deve valutare il messaggio di errore in base al validatore che fallisce.
+         *
+         * Se fallisce il required validator scriverà che l'input è obbligatorio, se invece fallisce
+         * un eventuale pattern validator scriverà che il formato dell'input è invalido
+         */
+        this.InferErrorMessages = true;
+        /**
+         * Messaggio da mostrare se la validazione fallisce.
+         *
+         * Se questo è valorizzato, il messaggio non viene valutato in automatico nonstante **InferErrorMessages** sia **true**
+         */
+        this.validationFailed = "";
+        /**
+         * Indica se il componente è in sola lettura
+         */
+        this.readonly = false;
+        /**
+         * Indica le dimensioni del componente
+         */
+        this.widthPx = null;
+        /**
+         * Indica se il componente è disabilitato o no (più o meno stesso concetto del readonly)
+         */
+        this.disabled = false;
+        /**
+         * Eventuale placeholder da mostrare al posto del valore quando il valore è nullo / vuoto
+         */
+        this.placeholder = "";
+        /**
+         * Classi da applicare al componente
+         */
+        this.class = "";
+        /**
+         * Stili da applicare al componente
+         */
+        this.style = "";
+        /**
+         * Pattern di validazione dell'input
+         */
+        this.pattern = "";
+        /**
+         * Indica di non validare il componente
+         */
+        this.noValidate = false;
+        /**
+         * Indica se abilitare o meno l'autocompletamento di default del browser
+         */
+        this.autocomplete = "off";
+        /**
+         * Evento che sostituisce l'ngModelChange facendolo funzionare in maniera un po' più consistente
+         */
+        this.inputChange = new EventEmitter();
+        /**
+         * @ignore
+         */
+        this.propagateChange = (_) => { };
+    }
+    /**
+     * Query che raccoglie il tooltip in maniera dinamica (ad ogni change detection)
+     *
+     * @param {TooltipDirective} comp Elemento HTML a cui è applicata la direttiva del tooltip
+     */
+    set tooltip_static(comp) {
+        if (comp) {
+            this.tooltip = comp;
+        }
+    }
+    ;
+    /**
+     * Query che raccoglie l'input o direttiva che contiene il valore in maniera dinamica (ad ogni change detection)
+     *
+     * @param {NgModel} comp Elemento HTML associato al ngModel del componente
+     */
+    set baseInput_static(comp) {
+        if (comp) {
+            this.baseInput = comp;
+        }
+    }
+    ;
+    /**
+     * Imposta il componente come "submitted" scatenandone le validazioni ed eventualmente la visualizzazione del tooltip di errore
+     *
+     * @param {boolean} val **true** se si vuole impostare questo controllo come submitted, **false** altrimenti
+     */
+    set submitted(val) {
+        this._submitted = val;
+        if (!this.baseInput)
+            return;
+        if (val)
+            this.baseInput.control.markAsTouched();
+        if (this.baseInput.control.status === "INVALID" && val)
+            this.showTooltipWithMessage();
+        else
+            this.tooltip.hide();
+    }
+    /**
+     * Imposta il componente come "invalid" a prescindere dai validatori
+     */
+    set forceInvalid(val) {
+        this._forceInvalid = val;
+        if (val)
+            setTimeout(() => this.baseInput.control.setErrors({ forcedtoinvalid: true }));
+        else
+            setTimeout(() => {
+                this.baseInput.control.setErrors({ forcedtoinvalid: null });
+                this.baseInput.control.updateValueAndValidity();
+            });
+    }
+    /**
+     * Helper che controlla se il tooltip deve essere mostrato o meno,
+     * richiamato direttamente dall'HTML dei componenti
+     */
+    checkTooltip() {
+        if ((this.baseInput.invalid && this.baseInput.touched))
+            this.showTooltipWithMessage();
+    }
+    /**
+     * Helper che calcola il messaggio da mostrare nel tooltip che andrà ad aprire
+     */
+    showTooltipWithMessage() {
+        this.validationFailed = this.validationFailed ? this.validationFailed : this.InferErrorMessages ? this.inferMessage() : "";
+        if (this.validationFailed)
+            this.tooltip.show();
+    }
+    /**
+     * Calcola il messaggio da mostrare in base al valore.
+     *
+     * Entrare in questa funzione significa che lo stato di validazione è fallito, per questo si comporta semplicemente in maniera esclusiva, e cioè:
+     *
+     * 1) Se ero required e sono senza valore --> Input richiesto
+     *
+     * 2) Altrimenti se ho un valore --> Di sicuro il formato è errato
+     */
+    inferMessage() {
+        if (this.required && !this.baseInput.value)
+            return this.lc.loc("Required Input");
+        if (this.baseInput.value)
+            return this.lc.loc("Invalid Input Format");
+    }
+    /**
+     * Forza la chiusura del tooltip
+     */
+    closeTooltip() {
+        this.tooltip.hide();
+    }
+    /**
+     * Controlla se il controllo è valido e in caso lo sia chiude il tooltip
+     */
+    CheckValidity() {
+        if (!this.baseInput.statusChanges)
+            return;
+        this.baseInput.statusChanges.subscribe(event => {
+            if (event === "VALID")
+                this.tooltip.hide();
+        });
+    }
+    /**
+     * @ignore
+     */
+    setDisabledState(isDisabled) {
+        isDisabled ? this.baseInput.control.disable() : this.baseInput.control.enable();
+        this.readonly = isDisabled;
+    }
+}
+BaseValidation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseValidation, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+BaseValidation.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BaseValidation, inputs: { InferErrorMessages: "InferErrorMessages", validationFailed: "validationFailed", readonly: "readonly", widthPx: "widthPx", disabled: "disabled", placeholder: "placeholder", class: "class", style: "style", pattern: "pattern", noValidate: "noValidate", autocomplete: "autocomplete", submitted: "submitted", forceInvalid: "forceInvalid" }, outputs: { inputChange: "inputChange" }, viewQueries: [{ propertyName: "tooltip", first: true, predicate: TooltipDirective, descendants: true }, { propertyName: "tooltip_static", first: true, predicate: TooltipDirective, descendants: true, static: true }, { propertyName: "baseInput", first: true, predicate: ["baseInput"], descendants: true }, { propertyName: "baseInput_static", first: true, predicate: ["baseInput"], descendants: true, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseValidation, decorators: [{
+            type: Directive
+        }], propDecorators: { tooltip: [{
+                type: ViewChild,
+                args: [TooltipDirective, { static: false }]
+            }], tooltip_static: [{
+                type: ViewChild,
+                args: [TooltipDirective, { static: true }]
+            }], baseInput: [{
+                type: ViewChild,
+                args: ["baseInput", { static: false }]
+            }], baseInput_static: [{
+                type: ViewChild,
+                args: ["baseInput", { static: true }]
+            }], InferErrorMessages: [{
+                type: Input
+            }], validationFailed: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], widthPx: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], pattern: [{
+                type: Input
+            }], noValidate: [{
+                type: Input
+            }], autocomplete: [{
+                type: Input
+            }], inputChange: [{
+                type: Output
+            }], submitted: [{
+                type: Input,
+                args: ["submitted"]
+            }], forceInvalid: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-validation.js","sourceRoot":"","sources":["../../../../../projects/forms-and-validations/src/lib/validations/base-validation.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { EventEmitter, Input, Output, ViewChild, Directive } from \"@angular/core\";\r\nimport { NgModel } from \"@angular/forms\";\r\n\r\n// Configurazioni\r\nimport { LocalizationService } from \"@esfaenza/localizations\";\r\n\r\n// Direttive, Componenti, Librerie\r\nimport { TooltipDirective } from \"ngx-bootstrap/tooltip\";\r\n\r\n/**\r\n * Classe astratta base che contiene le logiche / proprietà in comune a tutti i validatori\r\n * \r\n * Nota bene: I tooltip rallentano tantissimo la pagina perché il tizio che ha fatto ngx bootstrap non è capace\r\n */\r\n@Directive()\r\nexport abstract class BaseValidation {\r\n\r\n    /**\r\n     * Servizio di localizzazione del Componente\r\n     */\r\n    protected lc: LocalizationService;\r\n\r\n    /**\r\n     * Variabile per tenere in memoria lo stato di submit di questo componente\r\n     */\r\n    protected _submitted: boolean;\r\n\r\n    /**\r\n     * Variabile per tenere in memoria il fatto che il componente è forzato a invalido o no\r\n     */\r\n    protected _forceInvalid: boolean = false;\r\n\r\n    /**\r\n     * Indica se il valore è obbligatorio o opzionale\r\n     */\r\n    public required: boolean = false;\r\n\r\n    /**\r\n     * Query che raccoglie il tooltip in maniera statica (solo all'inizio)\r\n     */\r\n    @ViewChild(TooltipDirective, { static: false }) protected tooltip: TooltipDirective;\r\n\r\n    /**\r\n     * Query che raccoglie il tooltip in maniera dinamica (ad ogni change detection)\r\n     * \r\n     * @param {TooltipDirective} comp Elemento HTML a cui è applicata la direttiva del tooltip\r\n     */\r\n    @ViewChild(TooltipDirective, { static: true }) set tooltip_static(comp: TooltipDirective) {\r\n        if (comp) { this.tooltip = comp; }\r\n    };\r\n\r\n    /**\r\n     * Query che raccoglie l'input o direttiva che contiene il valore in maniera statica (solo all'inizio)\r\n     */\r\n    @ViewChild(\"baseInput\", { static: false }) baseInput: NgModel;\r\n\r\n    /**\r\n     * Query che raccoglie l'input o direttiva che contiene il valore in maniera dinamica (ad ogni change detection)\r\n     * \r\n     * @param {NgModel} comp Elemento HTML associato al ngModel del componente\r\n     */\r\n    @ViewChild(\"baseInput\", { static: true }) set baseInput_static(comp: NgModel) {\r\n        if (comp) { this.baseInput = comp; }\r\n    };\r\n\r\n    /**\r\n     * Indica se di default deve valutare il messaggio di errore in base al validatore che fallisce.\r\n     * \r\n     * Se fallisce il required validator scriverà che l'input è obbligatorio, se invece fallisce \r\n     * un eventuale pattern validator scriverà che il formato dell'input è invalido\r\n     */\r\n    @Input() InferErrorMessages: boolean = true;\r\n\r\n    /**\r\n     * Messaggio da mostrare se la validazione fallisce. \r\n     * \r\n     * Se questo è valorizzato, il messaggio non viene valutato in automatico nonstante **InferErrorMessages** sia **true**\r\n     */\r\n    @Input() validationFailed: string = \"\";\r\n\r\n    /**\r\n     * Indica se il componente è in sola lettura\r\n     */\r\n    @Input() readonly: boolean = false;\r\n\r\n    /**\r\n     * Indica le dimensioni del componente\r\n     */\r\n    @Input() widthPx: number = null;\r\n\r\n    /**\r\n     * Indica se il componente è disabilitato o no (più o meno stesso concetto del readonly)\r\n     */\r\n    @Input() disabled: boolean = false;\r\n\r\n    /**\r\n     * Eventuale placeholder da mostrare al posto del valore quando il valore è nullo / vuoto\r\n     */\r\n    @Input() placeholder: string = \"\";\r\n\r\n    /**\r\n     * Classi da applicare al componente\r\n     */\r\n    @Input() class: string = \"\";\r\n\r\n    /**\r\n     * Stili da applicare al componente\r\n     */\r\n    @Input() style: string = \"\";\r\n\r\n    /**\r\n     * Pattern di validazione dell'input\r\n     */\r\n    @Input() pattern: string = \"\";\r\n\r\n    /**\r\n     * Indica di non validare il componente\r\n     */\r\n    @Input() noValidate: boolean = false;\r\n\r\n    /**\r\n     * Indica se abilitare o meno l'autocompletamento di default del browser\r\n     */\r\n    @Input() autocomplete: string = \"off\";\r\n\r\n    /**\r\n     * Evento che sostituisce l'ngModelChange facendolo funzionare in maniera un po' più consistente\r\n     */\r\n    @Output() inputChange: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n    /**\r\n     * Imposta il componente come \"submitted\" scatenandone le validazioni ed eventualmente la visualizzazione del tooltip di errore\r\n     * \r\n     * @param {boolean} val **true** se si vuole impostare questo controllo come submitted, **false** altrimenti\r\n     */\r\n    @Input(\"submitted\") set submitted(val: boolean) {\r\n        this._submitted = val;\r\n        if (!this.baseInput)\r\n            return;\r\n\r\n        if (val)\r\n            this.baseInput.control.markAsTouched();\r\n\r\n        if (this.baseInput.control.status === \"INVALID\" && val)\r\n            this.showTooltipWithMessage();\r\n        else\r\n            this.tooltip.hide();\r\n    }\r\n\r\n    /**\r\n     * Imposta il componente come \"invalid\" a prescindere dai validatori\r\n     */\r\n    @Input() set forceInvalid(val: boolean) {\r\n        this._forceInvalid = val;\r\n\r\n        if (val)\r\n            setTimeout(() => this.baseInput.control.setErrors({ forcedtoinvalid: true }));\r\n        else\r\n            setTimeout(() => {\r\n                this.baseInput.control.setErrors({ forcedtoinvalid: null });\r\n                this.baseInput.control.updateValueAndValidity();\r\n            });\r\n    }\r\n\r\n\r\n    /**\r\n     * Helper che controlla se il tooltip deve essere mostrato o meno, \r\n     * richiamato direttamente dall'HTML dei componenti\r\n     */\r\n    public checkTooltip() {\r\n        if ((this.baseInput.invalid && this.baseInput.touched))\r\n            this.showTooltipWithMessage();\r\n    }\r\n\r\n    /**\r\n     * Helper che calcola il messaggio da mostrare nel tooltip che andrà ad aprire\r\n     */\r\n    private showTooltipWithMessage() {\r\n        this.validationFailed = this.validationFailed ? this.validationFailed : this.InferErrorMessages ? this.inferMessage() : \"\";\r\n        if (this.validationFailed)\r\n            this.tooltip.show();\r\n    }\r\n\r\n    /**\r\n     * Calcola il messaggio da mostrare in base al valore.\r\n     * \r\n     * Entrare in questa funzione significa che lo stato di validazione è fallito, per questo si comporta semplicemente in maniera esclusiva, e cioè:\r\n     * \r\n     * 1) Se ero required e sono senza valore --> Input richiesto\r\n     * \r\n     * 2) Altrimenti se ho un valore --> Di sicuro il formato è errato\r\n     */\r\n    private inferMessage(): string {\r\n        if (this.required && !this.baseInput.value)\r\n            return this.lc.loc(\"Required Input\")\r\n\r\n        if (this.baseInput.value)\r\n            return this.lc.loc(\"Invalid Input Format\")\r\n    }\r\n\r\n    /**\r\n     * Forza la chiusura del tooltip\r\n     */\r\n    closeTooltip() {\r\n        this.tooltip.hide();\r\n    }\r\n\r\n    /**\r\n     * Controlla se il controllo è valido e in caso lo sia chiude il tooltip\r\n     */\r\n    protected CheckValidity() {\r\n        if (!this.baseInput.statusChanges)\r\n            return;\r\n\r\n        this.baseInput.statusChanges.subscribe(event => {\r\n            if (event === \"VALID\")\r\n                this.tooltip.hide();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    setDisabledState?(isDisabled: boolean): void {\r\n        isDisabled ? this.baseInput.control.disable() : this.baseInput.control.enable();\r\n        this.readonly = isDisabled;\r\n    }\r\n\r\n    /**\r\n     * @ignore\r\n     */\r\n    protected propagateChange = (_: any) => { };\r\n}"]}