@jooler/inputs 0.0.55 → 0.0.56

package/esm2022/lib/formcontrol-validation-msg-for-ng-select.directive.mjs

@@ -0,0 +1,126 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import { PrimaryColors } from './primary-colors';
+import { ValidationError } from './services/validation-message.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class FormControlValidationMsgDirectiveForNgSelect {
+    elRef;
+    control;
+    errorMessage;
+    showDot;
+    errorDivId;
+    afterEnd = true;
+    showBoxError = true;
+    validationError = ValidationError;
+    statusChangeSubscription;
+    constructor(elRef, control) {
+        this.elRef = elRef;
+        this.control = control;
+    }
+    ngOnInit() {
+        if (!this.errorDivId) {
+            this.errorDivId = this.control.name;
+        }
+        this.statusChangeSubscription = this.control.statusChanges.subscribe(status => {
+            if (status == 'INVALID' && this.control.touched) {
+                this.showNgSelectError();
+            }
+            else {
+                this.removeError();
+            }
+        });
+        this.control.valueChanges.subscribe({
+            next: () => {
+                if (this.control.errors && this.control.touched) {
+                    this.showNgSelectError();
+                }
+                else {
+                    this.removeError();
+                }
+            },
+        });
+    }
+    onFocusout() {
+        if (this.control.errors && this.control.touched) {
+            this.showNgSelectError();
+        }
+        else {
+            this.removeError();
+        }
+    }
+    removeError() {
+        this.errorMessage = '';
+        const errorElement = document.getElementById(this.errorDivId);
+        if (errorElement)
+            errorElement.remove();
+    }
+    showNgSelectError() {
+        this.removeError();
+        const valErrors = this.control.errors;
+        if (this.control.errors.length > 1) {
+            this.showDot = true;
+        }
+        else {
+            this.showDot = false;
+        }
+        if (valErrors) {
+            const keys = Object.keys(valErrors);
+            for (let i = 0; i < keys.length; i++) {
+                switch (keys[i]) {
+                    case 'required': {
+                        let message = this.validationError.getRelevantError(keys[i], valErrors);
+                        this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\u25CF ' + message : message}`;
+                        this.control.control.setErrors({ required: true, message: message }, { emitEvent: false });
+                        break;
+                    }
+                    case 'validatePhoneNumber': {
+                        let message = this.validationError.getRelevantError(keys[i], valErrors);
+                        this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\u25CF ' + message : message}`;
+                        this.control.control.setErrors({ validatePhoneNumber: true, message: message }, { emitEvent: false });
+                        break;
+                    }
+                    case 'customMessage': {
+                        console.log('valErrors', valErrors);
+                        let message = valErrors.message;
+                        this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\u25CF ' + message : message}`;
+                    }
+                }
+            }
+            if (this.showBoxError) {
+                const errDiv = `<div style="color:${PrimaryColors.$primaryRedColor}; width: ${this.afterEnd ? this.elRef.nativeElement.offsetWidth + 'px' : '100%'}; min-width: 100%; background-color: ${PrimaryColors.$primaryLightRedColor}; padding: .5rem; border-radius: .5rem; border: .1rem solid ${PrimaryColors.$primaryRedColor} ;border-left: .75rem solid ${PrimaryColors.$primaryRedColor};  margin-top:.5rem;  font-size: 1.2rem; " id="` +
+                    this.errorDivId +
+                    '">' +
+                    `<h3   style= " font-size: 1.3rem;  margin-bottom:.5rem; margin:0;  color:  ${PrimaryColors.$primaryRedColor}; font-weight: 700; line-height: 1.6rem;">` +
+                    'Please Complete all details' +
+                    '</h3>' +
+                    this.errorMessage +
+                    '</div>';
+                if (!this.afterEnd)
+                    this.elRef.nativeElement.parentElement.insertAdjacentHTML('afterend', errDiv);
+                else {
+                    this.elRef.nativeElement.insertAdjacentHTML('afterend', errDiv);
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormControlValidationMsgDirectiveForNgSelect, deps: [{ token: i0.ElementRef }, { token: i1.NgControl }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FormControlValidationMsgDirectiveForNgSelect, selector: "[appFormControlValidationMsgForNgSelect]", inputs: { afterEnd: "afterEnd", showBoxError: "showBoxError" }, host: { listeners: { "focusout": "onFocusout()" } }, providers: [NgModel], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormControlValidationMsgDirectiveForNgSelect, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appFormControlValidationMsgForNgSelect]',
+                    providers: [NgModel],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NgControl }]; }, propDecorators: { afterEnd: [{
+                type: Input,
+                args: ['afterEnd']
+            }], showBoxError: [{
+                type: Input,
+                args: ['showBoxError']
+            }], onFocusout: [{
+                type: HostListener,
+                args: ['focusout']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formcontrol-validation-msg-for-ng-select.directive.js","sourceRoot":"","sources":["../../../../projects/inputs/src/lib/formcontrol-validation-msg-for-ng-select.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, OnInit } from '@angular/core';\r\nimport { NgControl, NgModel, ValidationErrors } from '@angular/forms';\r\nimport { Subscription } from 'rxjs';\r\nimport { PrimaryColors } from './primary-colors';\r\nimport { ValidationError } from './services/validation-message.service';\r\n\r\n@Directive({\r\n  selector: '[appFormControlValidationMsgForNgSelect]',\r\n  providers: [NgModel],\r\n})\r\nexport class FormControlValidationMsgDirectiveForNgSelect implements OnInit {\r\n  errorMessage: any;\r\n  showDot: boolean;\r\n  errorDivId: string | number;\r\n  @Input('afterEnd') afterEnd: boolean = true;\r\n  @Input('showBoxError') showBoxError: boolean = true;\r\n  validationError = ValidationError;\r\n  statusChangeSubscription: Subscription;\r\n\r\n  constructor(\r\n    private elRef: ElementRef,\r\n    private control: NgControl\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    if (!this.errorDivId) {\r\n      this.errorDivId = this.control.name;\r\n    }\r\n    this.statusChangeSubscription = this.control.statusChanges.subscribe(status => {\r\n      if (status == 'INVALID' && this.control.touched) {\r\n        this.showNgSelectError();\r\n      } else {\r\n        this.removeError();\r\n      }\r\n    });\r\n    this.control.valueChanges.subscribe({\r\n      next: () => {\r\n        if (this.control.errors && this.control.touched) {\r\n          this.showNgSelectError();\r\n        } else {\r\n          this.removeError();\r\n        }\r\n      },\r\n    });\r\n  }\r\n\r\n  @HostListener('focusout')\r\n  onFocusout() {\r\n    if (this.control.errors && this.control.touched) {\r\n      this.showNgSelectError();\r\n    } else {\r\n      this.removeError();\r\n    }\r\n  }\r\n\r\n  private removeError(): void {\r\n    this.errorMessage = '';\r\n    const errorElement = document.getElementById(this.errorDivId as string);\r\n    if (errorElement) errorElement.remove();\r\n  }\r\n\r\n  private showNgSelectError() {\r\n    this.removeError();\r\n    const valErrors: ValidationErrors = this.control.errors;\r\n\r\n    if (this.control.errors.length > 1) {\r\n      this.showDot = true;\r\n    } else {\r\n      this.showDot = false;\r\n    }\r\n    if (valErrors) {\r\n      const keys = Object.keys(valErrors);\r\n      for (let i = 0; i < keys.length; i++) {\r\n        switch (keys[i]) {\r\n          case 'required': {\r\n            let message = this.validationError.getRelevantError(keys[i], valErrors);\r\n            this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\\u25CF ' + message : message}`;\r\n            this.control.control.setErrors(\r\n              { required: true, message: message },\r\n              { emitEvent: false }\r\n            );\r\n            break;\r\n          }\r\n          case 'validatePhoneNumber': {\r\n            let message = this.validationError.getRelevantError(keys[i], valErrors);\r\n            this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\\u25CF ' + message : message}`;\r\n            this.control.control.setErrors(\r\n              { validatePhoneNumber: true, message: message },\r\n              { emitEvent: false }\r\n            );\r\n            break;\r\n          }\r\n          case 'customMessage': {\r\n            console.log('valErrors', valErrors);\r\n            let message = valErrors.message;\r\n            this.errorMessage += ` ${this.errorMessage ? '<br>' : ''}${this.showDot ? '\\u25CF ' + message : message}`;\r\n          }\r\n        }\r\n      }\r\n      if (this.showBoxError) {\r\n        const errDiv =\r\n          `<div style=\"color:${PrimaryColors.$primaryRedColor}; width: ${this.afterEnd ? this.elRef.nativeElement.offsetWidth + 'px' : '100%'}; min-width: 100%; background-color: ${PrimaryColors.$primaryLightRedColor}; padding: .5rem; border-radius: .5rem; border: .1rem solid ${PrimaryColors.$primaryRedColor} ;border-left: .75rem solid ${PrimaryColors.$primaryRedColor};  margin-top:.5rem;  font-size: 1.2rem; \" id=\"` +\r\n          this.errorDivId +\r\n          '\">' +\r\n          `<h3   style= \" font-size: 1.3rem;  margin-bottom:.5rem; margin:0;  color:  ${PrimaryColors.$primaryRedColor}; font-weight: 700; line-height: 1.6rem;\">` +\r\n          'Please Complete all details' +\r\n          '</h3>' +\r\n          this.errorMessage +\r\n          '</div>';\r\n        if (!this.afterEnd)\r\n          this.elRef.nativeElement.parentElement.insertAdjacentHTML('afterend', errDiv);\r\n        else {\r\n          this.elRef.nativeElement.insertAdjacentHTML('afterend', errDiv);\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/inputs.module.mjs

@@ -1,26 +1,28 @@
 import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
-import { NgSelectModule } from '@ng-select/ng-select';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { AppMaterialModule } from '@jooler/app-material';
 import { SharedGeneralComponentsModule } from '@jooler/shared-general-components';
-import { ChooseEnumComponent } from './choose-enum/choose-enum.component';
+import { NgSelectModule } from '@ng-select/ng-select';
+import { AddAsteriskDirective } from './add-asterisk.directive';
 import { ChooseEnumRendererComponent } from './choose-enum-renderer/choose-enum-renderer.component';
+import { ChooseEnumComponent } from './choose-enum/choose-enum.component';
+import { ChooseGeneralItemRendererComponent } from './choose-general-item-renderer/choose-general-item-renderer.component';
 import { ChooseGeneralItemComponent } from './choose-general-item/choose-general-item.component';
+import { ChooseGeneralItemService } from './choose-general-item/choose-general-item.service';
 import { ChooseLineTypeComponent } from './choose-line-type/choose-line-type.component';
-import { ChooseYesOrNoComponent } from './choose-yes-or-no/choose-yes-or-no.component';
 import { ChooseYesOrNoRendererComponent } from './choose-yes-or-no-renderer/choose-yes-or-no-renderer.component';
-import { EditableSavableInputComponent } from './editable-savable-input/editable-savable-input.component';
-import { GeneralInputRendererComponent } from './general-input-renderer/general-input-renderer.component';
-import { AppMaterialModule } from '@jooler/app-material';
+import { ChooseYesOrNoComponent } from './choose-yes-or-no/choose-yes-or-no.component';
+import { DropdownActionsComponent } from './dropdown-actions/dropdown-actions.component';
 import { DynamicPipe } from './editable-savable-input/dynamicPipe';
-import { ChooseGeneralItemRendererComponent } from './choose-general-item-renderer/choose-general-item-renderer.component';
+import { EditableSavableInputComponent } from './editable-savable-input/editable-savable-input.component';
+import { FormControlValidationMsgDirectiveForNgSelect } from './formcontrol-validation-msg-for-ng-select.directive';
+import { FormControlValidationMsgDirectiveForInput } from './formcontrol-validation-msg.directive';
 import { CustomDecimalPointTwoDigitsDirective } from './general-input-renderer/custom-decimal-point-two-digits.directive';
+import { GeneralInputRendererComponent } from './general-input-renderer/general-input-renderer.component';
 import { ShowTableErrorsComponent } from './show-table-errors/show-table-errors.component';
-import { FormControlValidationMsgDirectiveForInput } from './formcontrol-validation-msg.directive';
-import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
-import { ChooseGeneralItemService } from './choose-general-item/choose-general-item.service';
-import { DropdownActionsComponent } from './dropdown-actions/dropdown-actions.component';
-import { AddAsteriskDirective } from './add-asterisk.directive';
+import { TooltipMsgError } from './tooltip-msg-error/tooltip-msg-error.component';
 import * as i0 from "@angular/core";
 export class InputsModule {
     static forRoot(environment) {
@@ -50,7 +52,9 @@ export class InputsModule {
             ShowTableErrorsComponent,
             FormControlValidationMsgDirectiveForInput,
             DropdownActionsComponent,
-            AddAsteriskDirective], imports: [CommonModule,
+            AddAsteriskDirective,
+            FormControlValidationMsgDirectiveForNgSelect,
+            TooltipMsgError], imports: [CommonModule,
             NgSelectModule,
             FormsModule,
             ReactiveFormsModule,
@@ -93,7 +97,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                         ShowTableErrorsComponent,
                         FormControlValidationMsgDirectiveForInput,
                         DropdownActionsComponent,
-                        AddAsteriskDirective
+                        AddAsteriskDirective,
+                        FormControlValidationMsgDirectiveForNgSelect,
+                        TooltipMsgError
                     ],
                     imports: [
                         CommonModule,
@@ -119,4 +125,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputs.module.js","sourceRoot":"","sources":["../../../../projects/inputs/src/lib/inputs.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\r\nimport { ModuleWithProviders, NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { NgSelectModule } from '@ng-select/ng-select';\r\nimport { SharedGeneralComponentsModule } from '@jooler/shared-general-components';\r\nimport { ChooseEnumComponent } from './choose-enum/choose-enum.component';\r\nimport { ChooseEnumRendererComponent } from './choose-enum-renderer/choose-enum-renderer.component';\r\nimport { ChooseGeneralItemComponent } from './choose-general-item/choose-general-item.component';\r\nimport { ChooseLineTypeComponent } from './choose-line-type/choose-line-type.component';\r\nimport { ChooseYesOrNoComponent } from './choose-yes-or-no/choose-yes-or-no.component';\r\nimport { ChooseYesOrNoRendererComponent } from './choose-yes-or-no-renderer/choose-yes-or-no-renderer.component';\r\nimport { EditableSavableInputComponent } from './editable-savable-input/editable-savable-input.component';\r\nimport { GeneralInputRendererComponent } from './general-input-renderer/general-input-renderer.component';\r\nimport { AppMaterialModule } from '@jooler/app-material';\r\nimport { DynamicPipe } from './editable-savable-input/dynamicPipe';\r\nimport { ChooseGeneralItemRendererComponent } from './choose-general-item-renderer/choose-general-item-renderer.component';\r\nimport { CustomDecimalPointTwoDigitsDirective } from './general-input-renderer/custom-decimal-point-two-digits.directive';\r\nimport { ShowTableErrorsComponent } from './show-table-errors/show-table-errors.component';\r\nimport { FormControlValidationMsgDirectiveForInput } from './formcontrol-validation-msg.directive';\r\nimport { FontAwesomeModule } from '@fortawesome/angular-fontawesome';\r\nimport { ChooseGeneralItemService } from './choose-general-item/choose-general-item.service';\r\nimport { DropdownActionsComponent } from './dropdown-actions/dropdown-actions.component';\r\nimport { AddAsteriskDirective } from './add-asterisk.directive';\r\n\r\n\r\n@NgModule({\r\n  declarations: [\r\n    ChooseEnumComponent,\r\n    ChooseEnumRendererComponent,\r\n    ChooseGeneralItemComponent,\r\n    GeneralInputRendererComponent,\r\n    ChooseLineTypeComponent,\r\n    ChooseYesOrNoComponent,\r\n    ChooseYesOrNoRendererComponent,\r\n    EditableSavableInputComponent,\r\n    DynamicPipe,\r\n    ChooseGeneralItemRendererComponent,\r\n    CustomDecimalPointTwoDigitsDirective,\r\n    ShowTableErrorsComponent,\r\n    FormControlValidationMsgDirectiveForInput,\r\n    DropdownActionsComponent,\r\n    AddAsteriskDirective\r\n  ],\r\n  imports: [\r\n    CommonModule,\r\n    NgSelectModule,\r\n    FormsModule,\r\n    ReactiveFormsModule,\r\n    AppMaterialModule,\r\n    SharedGeneralComponentsModule,\r\n    FontAwesomeModule,\r\n  ],\r\n  exports: [\r\n    ChooseEnumComponent,\r\n    ChooseEnumRendererComponent,\r\n    ChooseGeneralItemComponent,\r\n    GeneralInputRendererComponent,\r\n    ChooseLineTypeComponent,\r\n    ChooseYesOrNoComponent,\r\n    ChooseYesOrNoRendererComponent,\r\n    EditableSavableInputComponent,\r\n    DropdownActionsComponent,\r\n    DynamicPipe,\r\n    AddAsteriskDirective\r\n  ]\r\n})\r\nexport class InputsModule {\r\n\r\n  public static forRoot(environment: any): ModuleWithProviders<InputsModule> {\r\n\r\n    return {\r\n      ngModule: InputsModule,\r\n      providers: [\r\n        ChooseGeneralItemService,\r\n        {\r\n          provide: 'env',\r\n          useValue: environment\r\n        }\r\n      ]\r\n    };\r\n  }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputs.module.js","sourceRoot":"","sources":["../../../../projects/inputs/src/lib/inputs.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\r\nimport { ModuleWithProviders, NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { FontAwesomeModule } from '@fortawesome/angular-fontawesome';\r\nimport { AppMaterialModule } from '@jooler/app-material';\r\nimport { SharedGeneralComponentsModule } from '@jooler/shared-general-components';\r\nimport { NgSelectModule } from '@ng-select/ng-select';\r\nimport { AddAsteriskDirective } from './add-asterisk.directive';\r\nimport { ChooseEnumRendererComponent } from './choose-enum-renderer/choose-enum-renderer.component';\r\nimport { ChooseEnumComponent } from './choose-enum/choose-enum.component';\r\nimport { ChooseGeneralItemRendererComponent } from './choose-general-item-renderer/choose-general-item-renderer.component';\r\nimport { ChooseGeneralItemComponent } from './choose-general-item/choose-general-item.component';\r\nimport { ChooseGeneralItemService } from './choose-general-item/choose-general-item.service';\r\nimport { ChooseLineTypeComponent } from './choose-line-type/choose-line-type.component';\r\nimport { ChooseYesOrNoRendererComponent } from './choose-yes-or-no-renderer/choose-yes-or-no-renderer.component';\r\nimport { ChooseYesOrNoComponent } from './choose-yes-or-no/choose-yes-or-no.component';\r\nimport { DropdownActionsComponent } from './dropdown-actions/dropdown-actions.component';\r\nimport { DynamicPipe } from './editable-savable-input/dynamicPipe';\r\nimport { EditableSavableInputComponent } from './editable-savable-input/editable-savable-input.component';\r\nimport { FormControlValidationMsgDirectiveForNgSelect } from './formcontrol-validation-msg-for-ng-select.directive';\r\nimport { FormControlValidationMsgDirectiveForInput } from './formcontrol-validation-msg.directive';\r\nimport { CustomDecimalPointTwoDigitsDirective } from './general-input-renderer/custom-decimal-point-two-digits.directive';\r\nimport { GeneralInputRendererComponent } from './general-input-renderer/general-input-renderer.component';\r\nimport { ShowTableErrorsComponent } from './show-table-errors/show-table-errors.component';\r\nimport { TooltipMsgError } from './tooltip-msg-error/tooltip-msg-error.component';\r\n\r\n\r\n@NgModule({\r\n  declarations: [\r\n    ChooseEnumComponent,\r\n    ChooseEnumRendererComponent,\r\n    ChooseGeneralItemComponent,\r\n    GeneralInputRendererComponent,\r\n    ChooseLineTypeComponent,\r\n    ChooseYesOrNoComponent,\r\n    ChooseYesOrNoRendererComponent,\r\n    EditableSavableInputComponent,\r\n    DynamicPipe,\r\n    ChooseGeneralItemRendererComponent,\r\n    CustomDecimalPointTwoDigitsDirective,\r\n    ShowTableErrorsComponent,\r\n    FormControlValidationMsgDirectiveForInput,\r\n    DropdownActionsComponent,\r\n    AddAsteriskDirective,\r\n    FormControlValidationMsgDirectiveForNgSelect,\r\n    TooltipMsgError\r\n  ],\r\n  imports: [\r\n    CommonModule,\r\n    NgSelectModule,\r\n    FormsModule,\r\n    ReactiveFormsModule,\r\n    AppMaterialModule,\r\n    SharedGeneralComponentsModule,\r\n    FontAwesomeModule,\r\n  ],\r\n  exports: [\r\n    ChooseEnumComponent,\r\n    ChooseEnumRendererComponent,\r\n    ChooseGeneralItemComponent,\r\n    GeneralInputRendererComponent,\r\n    ChooseLineTypeComponent,\r\n    ChooseYesOrNoComponent,\r\n    ChooseYesOrNoRendererComponent,\r\n    EditableSavableInputComponent,\r\n    DropdownActionsComponent,\r\n    DynamicPipe,\r\n    AddAsteriskDirective\r\n  ]\r\n})\r\nexport class InputsModule {\r\n\r\n  public static forRoot(environment: any): ModuleWithProviders<InputsModule> {\r\n\r\n    return {\r\n      ngModule: InputsModule,\r\n      providers: [\r\n        ChooseGeneralItemService,\r\n        {\r\n          provide: 'env',\r\n          useValue: environment\r\n        }\r\n      ]\r\n    };\r\n  }\r\n}"]}

package/esm2022/lib/tooltip-msg-error/tooltip-message-type.enum.mjs

@@ -0,0 +1,8 @@
+export var ToolTipMessageType;
+(function (ToolTipMessageType) {
+    ToolTipMessageType[ToolTipMessageType["ERROR"] = 0] = "ERROR";
+    ToolTipMessageType[ToolTipMessageType["WARNING"] = 1] = "WARNING";
+    ToolTipMessageType[ToolTipMessageType["HELP"] = 2] = "HELP";
+    ToolTipMessageType[ToolTipMessageType["DEFAULT"] = 3] = "DEFAULT";
+})(ToolTipMessageType || (ToolTipMessageType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1tZXNzYWdlLXR5cGUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2lucHV0cy9zcmMvbGliL3Rvb2x0aXAtbXNnLWVycm9yL3Rvb2x0aXAtbWVzc2FnZS10eXBlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksa0JBS1g7QUFMRCxXQUFZLGtCQUFrQjtJQUM1Qiw2REFBUyxDQUFBO0lBQ1QsaUVBQVcsQ0FBQTtJQUNYLDJEQUFRLENBQUE7SUFDUixpRUFBVyxDQUFBO0FBQ2IsQ0FBQyxFQUxXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFLN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBUb29sVGlwTWVzc2FnZVR5cGUge1xyXG4gIEVSUk9SID0gMCxcclxuICBXQVJOSU5HID0gMSxcclxuICBIRUxQID0gMixcclxuICBERUZBVUxUID0gMyxcclxufVxyXG4iXX0=

package/esm2022/lib/tooltip-msg-error/tooltip-msg-error.component.mjs

@@ -0,0 +1,213 @@
+import { Component, HostListener, Input, } from '@angular/core';
+import { PrimaryColors } from '../primary-colors';
+import { ToolTipMessageType } from './tooltip-message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@fortawesome/angular-fontawesome";
+export class TooltipMsgError {
+    cdr;
+    _El;
+    width;
+    control = null;
+    messageType = ToolTipMessageType.ERROR;
+    message;
+    iconElId;
+    messageElId;
+    isLeft = true;
+    showDetails;
+    tooltipIcon;
+    tooltipMessage;
+    iconStyle;
+    isDictionary;
+    onScrollY() {
+        this.onMouseLeave();
+    }
+    constructor(cdr, _El) {
+        this.cdr = cdr;
+        this._El = _El;
+    }
+    ngOnInit() {
+        this.iconElId = this.generateRandomString();
+        this.messageElId = this.generateRandomString();
+        this.setIconStyle();
+        this.checkErrorType();
+    }
+    ngOnChanges(changes) {
+        this.checkErrorType();
+    }
+    ngOnDestroy() {
+        if (document.getElementById(this.messageElId)) {
+            document.getElementById(this.messageElId).remove();
+        }
+    }
+    checkErrorType() {
+        if (this.message) {
+            if (this.message.constructor == Object) {
+                this.isDictionary = true;
+            }
+            else if (typeof this.message === 'string') {
+                this.isDictionary = false;
+            }
+            else {
+                this.isDictionary = false;
+            }
+        }
+    }
+    getThemedMessageStyle() {
+        let backgroundColor;
+        let fontBorderColor;
+        switch (this.messageType) {
+            case ToolTipMessageType.ERROR:
+                backgroundColor = '#fde5f0';
+                fontBorderColor = PrimaryColors.$primaryPinkColor;
+                break;
+            case ToolTipMessageType.WARNING:
+                backgroundColor = '#fdefdd';
+                fontBorderColor = PrimaryColors.$primaryOrangeColor;
+                break;
+            case ToolTipMessageType.HELP:
+                backgroundColor = '#d1f9f2';
+                fontBorderColor = PrimaryColors.$primaryTealColor;
+                break;
+            default:
+                backgroundColor = PrimaryColors.$primaryLightGrayColor;
+                fontBorderColor = PrimaryColors.$primaryGrayColor;
+                break;
+        }
+        let style = {
+            'background-color': backgroundColor,
+            'font-weight': 'bold',
+            color: fontBorderColor,
+            border: '0.2rem solid ' + fontBorderColor,
+            'border-left': '0.5rem solid ' + fontBorderColor,
+        };
+        return style;
+    }
+    setMessageStyle() {
+        let style = {};
+        if (this.width) {
+            style['width'] = this.width;
+        }
+    }
+    get messageStyle() {
+        let commonMessageStyle = {};
+        if (this.width) {
+            commonMessageStyle['width'] = this.width;
+        }
+        return {
+            ...commonMessageStyle,
+            ...(this.showDetails ? this.getThemedMessageStyle() : {}),
+        };
+    }
+    setIconStyle() {
+        let backgroundColor;
+        switch (this.messageType) {
+            case ToolTipMessageType.ERROR:
+                backgroundColor = PrimaryColors.$primaryPinkColor;
+                break;
+            case ToolTipMessageType.WARNING:
+                backgroundColor = PrimaryColors.$primaryOrangeColor;
+                break;
+            case ToolTipMessageType.HELP:
+                backgroundColor = PrimaryColors.$primaryTealColor;
+                break;
+            default:
+                backgroundColor = PrimaryColors.$primaryGrayColor;
+                break;
+        }
+        let style = {
+            color: backgroundColor,
+        };
+        this.iconStyle = style;
+    }
+    onMouseEnter() {
+        this.showDetails = true;
+        //  CDR is needed to let the DOM know the box error has a width
+        this.cdr.detectChanges();
+        this.tooltipMessage = document.getElementById(this.messageElId);
+        if (this.message) {
+            this.getDirection(this.tooltipMessage);
+            document.body.appendChild(this.tooltipMessage);
+            let messageElement = document.getElementById(this.messageElId);
+            let icon = document.getElementById(this.iconElId);
+            let rect = icon.getBoundingClientRect();
+            let top = rect.top;
+            let left = rect.left;
+            let right = rect.right;
+            let appendedLeft;
+            let appendedRight;
+            let appendedTop = top - messageElement.offsetHeight;
+            this.tooltipMessage.style.top = appendedTop + 'px';
+            this.tooltipMessage.style.zIndex = '1000';
+            if (this.isLeft) {
+                appendedLeft = left + icon.offsetWidth - 5;
+                this.tooltipMessage.style.left = appendedLeft + 'px';
+            }
+            else {
+                appendedRight = window.innerWidth - right + 5;
+                this.tooltipMessage.style.right = appendedRight + 'px';
+            }
+        }
+    }
+    onMouseLeave() {
+        this.showDetails = false;
+    }
+    getDirection(element) {
+        //  Calculating the width difference between  screen width minus the poistion of the icon from left to right (getBoundingClientRect().right)
+        let difference = window.innerWidth - element.getBoundingClientRect().right;
+        // hard coded + 12 is for the padding that has been added to router-outlet
+        // The if statment here check if there is enough space for the box error to show from left to right , if not enough space, the box error will pop up from right to left
+        if (difference <= element.offsetWidth + 12) {
+            this.isLeft = false;
+        }
+        else {
+            this.isLeft = true;
+        }
+    }
+    generateRandomString() {
+        let charsAndNumbs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
+        let text = '';
+        for (let i = 0; i < 8; i++) {
+            text += charsAndNumbs.charAt(Math.floor(Math.random() * charsAndNumbs.length));
+        }
+        return text;
+    }
+    // Helper to decide how to display the value
+    formatValue(value) {
+        if (!value)
+            return '';
+        // 1. If it's an array (like your jurisdiction error)
+        if (Array.isArray(value)) {
+            // Map through the array and extract 'message' if it exists, otherwise stringify
+            return value
+                .map(item => {
+                return typeof item === 'object' && item.message ? item.message : JSON.stringify(item);
+            })
+                .join(', ');
+        }
+        // 2. If it's a single object (but not an array)
+        if (typeof value === 'object') {
+            return value.message || JSON.stringify(value);
+        }
+        // 3. It's a string or number
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipMsgError, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TooltipMsgError, selector: "tooltip-msg-error", inputs: { width: "width", control: "control", messageType: "messageType", message: "message" }, host: { listeners: { "document:scroll ": "onScrollY()" } }, usesOnChanges: true, ngImport: i0, template: "<div\r\n  *ngIf=\"message && !control\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [id]=\"iconElId\" [ngStyle]=\"iconStyle\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    *ngIf=\"!isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    {{ message }}\r\n  </div>\r\n\r\n  <div\r\n    *ngIf=\"isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div\r\n  *ngIf=\"control?.touched && control.errors\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [ngStyle]=\"iconStyle\" [id]=\"iconElId\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n", styles: [".no-details{display:none;position:unset}.icon{cursor:pointer;display:inline-block}.container{position:relative}.details{position:fixed;display:block;z-index:1000;border-radius:.5rem;padding:.75rem 1rem;width:max-content;max-width:500px;font-size:1.2rem;line-height:1.4}@media (max-width: 1024px){.details{max-width:320px}}@media (max-width: 768px){.details{max-width:90vw}}.right-section{right:0}.message{width:max-content;white-space:pre-line;pointer-events:none}.dict-cont{line-height:normal}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: i2.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "classes", "transform", "a11yRole"] }, { kind: "pipe", type: i1.KeyValuePipe, name: "keyvalue" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipMsgError, decorators: [{
+            type: Component,
+            args: [{ selector: 'tooltip-msg-error', template: "<div\r\n  *ngIf=\"message && !control\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [id]=\"iconElId\" [ngStyle]=\"iconStyle\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    *ngIf=\"!isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    {{ message }}\r\n  </div>\r\n\r\n  <div\r\n    *ngIf=\"isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div\r\n  *ngIf=\"control?.touched && control.errors\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [ngStyle]=\"iconStyle\" [id]=\"iconElId\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n", styles: [".no-details{display:none;position:unset}.icon{cursor:pointer;display:inline-block}.container{position:relative}.details{position:fixed;display:block;z-index:1000;border-radius:.5rem;padding:.75rem 1rem;width:max-content;max-width:500px;font-size:1.2rem;line-height:1.4}@media (max-width: 1024px){.details{max-width:320px}}@media (max-width: 768px){.details{max-width:90vw}}.right-section{right:0}.message{width:max-content;white-space:pre-line;pointer-events:none}.dict-cont{line-height:normal}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, propDecorators: { width: [{
+                type: Input
+            }], control: [{
+                type: Input
+            }], messageType: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], onScrollY: [{
+                type: HostListener,
+                args: ['document:scroll ']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip-msg-error.component.js","sourceRoot":"","sources":["../../../../../projects/inputs/src/lib/tooltip-msg-error/tooltip-msg-error.component.ts","../../../../../projects/inputs/src/lib/tooltip-msg-error/tooltip-msg-error.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  HostListener,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  SimpleChanges,\r\n} from '@angular/core';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { PrimaryColors } from '../primary-colors';\r\nimport { ToolTipMessageType } from './tooltip-message-type.enum';\r\n\r\n@Component({\r\n  selector: 'tooltip-msg-error',\r\n  templateUrl: './tooltip-msg-error.component.html',\r\n  styleUrls: ['./tooltip-msg-error.component.scss'],\r\n})\r\nexport class TooltipMsgError implements OnInit, OnChanges, OnDestroy {\r\n  @Input() width: string;\r\n  @Input() control: AbstractControl | null = null;\r\n  @Input() messageType: ToolTipMessageType = ToolTipMessageType.ERROR;\r\n  @Input() message: any;\r\n  iconElId: string;\r\n  messageElId: string;\r\n  isLeft: boolean = true;\r\n  showDetails: boolean;\r\n  tooltipIcon: HTMLElement;\r\n  tooltipMessage: HTMLElement;\r\n  iconStyle: any;\r\n  isDictionary: boolean;\r\n\r\n  @HostListener('document:scroll ')\r\n  onScrollY() {\r\n    this.onMouseLeave();\r\n  }\r\n\r\n  constructor(\r\n    private cdr: ChangeDetectorRef,\r\n    private _El: ElementRef\r\n  ) { }\r\n\r\n  ngOnInit() {\r\n    this.iconElId = this.generateRandomString();\r\n    this.messageElId = this.generateRandomString();\r\n    this.setIconStyle();\r\n    this.checkErrorType();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    this.checkErrorType();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    if (document.getElementById(this.messageElId)) {\r\n      document.getElementById(this.messageElId).remove();\r\n    }\r\n  }\r\n\r\n  checkErrorType() {\r\n    if (this.message) {\r\n      if (this.message.constructor == Object) {\r\n        this.isDictionary = true;\r\n      } else if (typeof this.message === 'string') {\r\n        this.isDictionary = false;\r\n      } else {\r\n        this.isDictionary = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  getThemedMessageStyle() {\r\n    let backgroundColor: string;\r\n    let fontBorderColor: string;\r\n\r\n    switch (this.messageType) {\r\n      case ToolTipMessageType.ERROR:\r\n        backgroundColor = '#fde5f0';\r\n        fontBorderColor = PrimaryColors.$primaryPinkColor;\r\n        break;\r\n      case ToolTipMessageType.WARNING:\r\n        backgroundColor = '#fdefdd';\r\n        fontBorderColor = PrimaryColors.$primaryOrangeColor;\r\n\r\n        break;\r\n      case ToolTipMessageType.HELP:\r\n        backgroundColor = '#d1f9f2';\r\n        fontBorderColor = PrimaryColors.$primaryTealColor;\r\n        break;\r\n      default:\r\n        backgroundColor = PrimaryColors.$primaryLightGrayColor;\r\n        fontBorderColor = PrimaryColors.$primaryGrayColor;\r\n        break;\r\n    }\r\n    let style = {\r\n      'background-color': backgroundColor,\r\n      'font-weight': 'bold',\r\n      color: fontBorderColor,\r\n      border: '0.2rem solid ' + fontBorderColor,\r\n      'border-left': '0.5rem solid ' + fontBorderColor,\r\n    };\r\n\r\n    return style;\r\n  }\r\n\r\n  setMessageStyle() {\r\n    let style = {};\r\n\r\n    if (this.width) {\r\n      style['width'] = this.width;\r\n    }\r\n  }\r\n\r\n  get messageStyle() {\r\n    let commonMessageStyle = {};\r\n\r\n    if (this.width) {\r\n      commonMessageStyle['width'] = this.width;\r\n    }\r\n    return {\r\n      ...commonMessageStyle,\r\n      ...(this.showDetails ? this.getThemedMessageStyle() : {}),\r\n    };\r\n  }\r\n\r\n  setIconStyle() {\r\n    let backgroundColor: string;\r\n    switch (this.messageType) {\r\n      case ToolTipMessageType.ERROR:\r\n        backgroundColor = PrimaryColors.$primaryPinkColor;\r\n        break;\r\n      case ToolTipMessageType.WARNING:\r\n        backgroundColor = PrimaryColors.$primaryOrangeColor;\r\n        break;\r\n      case ToolTipMessageType.HELP:\r\n        backgroundColor = PrimaryColors.$primaryTealColor;\r\n        break;\r\n      default:\r\n        backgroundColor = PrimaryColors.$primaryGrayColor;\r\n        break;\r\n    }\r\n    let style = {\r\n      color: backgroundColor,\r\n    };\r\n\r\n    this.iconStyle = style;\r\n  }\r\n\r\n  onMouseEnter() {\r\n    this.showDetails = true;\r\n    //  CDR is needed to let the DOM know the box error has a width\r\n    this.cdr.detectChanges();\r\n    this.tooltipMessage = document.getElementById(this.messageElId);\r\n    if (this.message) {\r\n      this.getDirection(this.tooltipMessage);\r\n      document.body.appendChild(this.tooltipMessage);\r\n      let messageElement = document.getElementById(this.messageElId);\r\n      let icon = document.getElementById(this.iconElId);\r\n      let rect = icon.getBoundingClientRect();\r\n\r\n      let top = rect.top;\r\n      let left = rect.left;\r\n      let right = rect.right;\r\n      let appendedLeft: number;\r\n      let appendedRight: number;\r\n      let appendedTop = top - messageElement.offsetHeight;\r\n      this.tooltipMessage.style.top = appendedTop + 'px';\r\n      this.tooltipMessage.style.zIndex = '1000';\r\n\r\n      if (this.isLeft) {\r\n        appendedLeft = left + icon.offsetWidth - 5;\r\n        this.tooltipMessage.style.left = appendedLeft + 'px';\r\n      } else {\r\n        appendedRight = window.innerWidth - right + 5;\r\n        this.tooltipMessage.style.right = appendedRight + 'px';\r\n      }\r\n    }\r\n  }\r\n\r\n  onMouseLeave() {\r\n    this.showDetails = false;\r\n  }\r\n\r\n  getDirection(element) {\r\n    //  Calculating the width difference between  screen width minus the poistion of the icon from left to right (getBoundingClientRect().right)\r\n    let difference = window.innerWidth - element.getBoundingClientRect().right;\r\n    // hard coded + 12 is for the padding that has been added to router-outlet\r\n    // The if statment here check if there is enough space for the box error to show from left to right , if not enough space, the box error will pop up from right to left\r\n    if (difference <= element.offsetWidth + 12) {\r\n      this.isLeft = false;\r\n    } else {\r\n      this.isLeft = true;\r\n    }\r\n  }\r\n\r\n  generateRandomString() {\r\n    let charsAndNumbs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';\r\n    let text = '';\r\n    for (let i = 0; i < 8; i++) {\r\n      text += charsAndNumbs.charAt(Math.floor(Math.random() * charsAndNumbs.length));\r\n    }\r\n    return text;\r\n  }\r\n\r\n  // Helper to decide how to display the value\r\n  formatValue(value: any): string {\r\n    if (!value) return '';\r\n\r\n    // 1. If it's an array (like your jurisdiction error)\r\n    if (Array.isArray(value)) {\r\n      // Map through the array and extract 'message' if it exists, otherwise stringify\r\n      return value\r\n        .map(item => {\r\n          return typeof item === 'object' && item.message ? item.message : JSON.stringify(item);\r\n        })\r\n        .join(', ');\r\n    }\r\n\r\n    // 2. If it's a single object (but not an array)\r\n    if (typeof value === 'object') {\r\n      return value.message || JSON.stringify(value);\r\n    }\r\n\r\n    // 3. It's a string or number\r\n    return value;\r\n  }\r\n}\r\n","<div\r\n  *ngIf=\"message && !control\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [id]=\"iconElId\" [ngStyle]=\"iconStyle\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    *ngIf=\"!isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    {{ message }}\r\n  </div>\r\n\r\n  <div\r\n    *ngIf=\"isDictionary\"\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n\r\n<div\r\n  *ngIf=\"control?.touched && control.errors\"\r\n  class=\"container\"\r\n  (mouseenter)=\"onMouseEnter()\"\r\n  (mouseleave)=\"onMouseLeave()\">\r\n  <fa-icon [ngStyle]=\"iconStyle\" [id]=\"iconElId\" icon=\"circle-exclamation\" class=\"icon\"></fa-icon>\r\n  <div\r\n    [ngStyle]=\"messageStyle\"\r\n    [id]=\"messageElId\"\r\n    class=\"message\"\r\n    [ngClass]=\"{ 'no-details': !showDetails, details: showDetails }\">\r\n    <div class=\"dict-cont\" *ngFor=\"let entry of message | keyvalue\">\r\n      <strong>{{ entry.key }}: </strong>\r\n      <span>{{ formatValue(entry.value) }}</span>\r\n    </div>\r\n  </div>\r\n</div>\r\n"]}

package/esm2022/public-api.mjs

@@ -1,24 +1,28 @@
 /*
  * Public API Surface of inputs
  */
-export * from './lib/choose-enum/choose-enum.component';
-export * from './lib/show-table-errors/show-table-errors.component';
 export * from './lib/choose-enum-renderer/choose-enum-renderer.component';
+export * from './lib/choose-enum/choose-enum.component';
+export * from './lib/choose-general-item-renderer/choose-general-item-renderer-change-event.interface';
+export * from './lib/choose-general-item-renderer/choose-general-item-renderer-validation-type.enum';
 export * from './lib/choose-general-item/choose-general-item.component';
+export * from './lib/show-table-errors/show-table-errors.component';
+export * from './lib/tooltip-msg-error/tooltip-message-type.enum';
+export * from './lib/tooltip-msg-error/tooltip-msg-error.component';
+export * from './lib/add-asterisk.directive';
 export * from './lib/choose-general-item-renderer/choose-general-item-renderer.component';
+export * from './lib/choose-general-item/choose-general-item.service';
 export * from './lib/choose-line-type/choose-line-type.component';
-export * from './lib/choose-yes-or-no/choose-yes-or-no.component';
 export * from './lib/choose-yes-or-no-renderer/choose-yes-or-no-renderer.component';
-export * from './lib/editable-savable-input/editable-savable-input.component';
-export * from './lib/general-input-renderer/general-input-renderer.component';
+export * from './lib/choose-yes-or-no/choose-yes-or-no.component';
+export * from './lib/dropdown-actions/dropdown-action-type.model';
+export * from './lib/dropdown-actions/dropdown-actions.component';
+export * from './lib/dropdown-actions/label-and-route.model';
 export * from './lib/editable-savable-input/dynamicPipe';
-export * from './lib/choose-general-item/choose-general-item.service';
-export * from './lib/models/label-and-field.model';
+export * from './lib/editable-savable-input/editable-savable-input.component';
 export * from './lib/formcontrol-validation-msg.directive';
+export * from './lib/general-input-renderer/general-input-renderer.component';
 export * from './lib/inputs.module';
-export * from './lib/dropdown-actions/dropdown-actions.component';
-export * from './lib/dropdown-actions/label-and-route.model';
-export * from './lib/dropdown-actions/dropdown-action-type.model';
-export * from './lib/add-asterisk.directive';
+export * from './lib/models/label-and-field.model';
 export * from './lib/primary-colors';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2lucHV0cy9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLDJEQUEyRCxDQUFDO0FBQzFFLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYywyRUFBMkUsQ0FBQztBQUMxRixjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsbURBQW1ELENBQUM7QUFDbEUsY0FBYyxxRUFBcUUsQ0FBQztBQUNwRixjQUFjLCtEQUErRCxDQUFDO0FBQzlFLGNBQWMsK0RBQStELENBQUM7QUFDOUUsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsbURBQW1ELENBQUM7QUFDbEUsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBpbnB1dHNcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaG9vc2UtZW51bS9jaG9vc2UtZW51bS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaG93LXRhYmxlLWVycm9ycy9zaG93LXRhYmxlLWVycm9ycy5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaG9vc2UtZW51bS1yZW5kZXJlci9jaG9vc2UtZW51bS1yZW5kZXJlci5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaG9vc2UtZ2VuZXJhbC1pdGVtL2Nob29zZS1nZW5lcmFsLWl0ZW0uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY2hvb3NlLWdlbmVyYWwtaXRlbS1yZW5kZXJlci9jaG9vc2UtZ2VuZXJhbC1pdGVtLXJlbmRlcmVyLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nob29zZS1saW5lLXR5cGUvY2hvb3NlLWxpbmUtdHlwZS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaG9vc2UteWVzLW9yLW5vL2Nob29zZS15ZXMtb3Itbm8uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY2hvb3NlLXllcy1vci1uby1yZW5kZXJlci9jaG9vc2UteWVzLW9yLW5vLXJlbmRlcmVyLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2VkaXRhYmxlLXNhdmFibGUtaW5wdXQvZWRpdGFibGUtc2F2YWJsZS1pbnB1dC5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9nZW5lcmFsLWlucHV0LXJlbmRlcmVyL2dlbmVyYWwtaW5wdXQtcmVuZGVyZXIuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZWRpdGFibGUtc2F2YWJsZS1pbnB1dC9keW5hbWljUGlwZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Nob29zZS1nZW5lcmFsLWl0ZW0vY2hvb3NlLWdlbmVyYWwtaXRlbS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzL2xhYmVsLWFuZC1maWVsZC5tb2RlbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Zvcm1jb250cm9sLXZhbGlkYXRpb24tbXNnLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2lucHV0cy5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kcm9wZG93bi1hY3Rpb25zL2Ryb3Bkb3duLWFjdGlvbnMuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZHJvcGRvd24tYWN0aW9ucy9sYWJlbC1hbmQtcm91dGUubW9kZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kcm9wZG93bi1hY3Rpb25zL2Ryb3Bkb3duLWFjdGlvbi10eXBlLm1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvYWRkLWFzdGVyaXNrLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3ByaW1hcnktY29sb3JzJztcclxuXHJcblxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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