@fagon/ngx-intellitoolx 16.0.3 → 16.0.5

package/README.md

@@ -1,10 +1,15 @@
 # IntelliToolx
 
+![npm version](https://img.shields.io/npm/v/@fagon/ngx-intellittolx.svg)
+![npm downloads](https://img.shields.io/npm/dm/@fagon/ngx-intellittolx.svg)
+![bundle size](https://img.shields.io/bundlephobia/minzip/@fagon/ngx-intellittolx)
 ![Angular](https://img.shields.io/badge/Angular-14%2B-red)
-![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)
-![License](https://img.shields.io/badge/License-MIT-green)
+![TypeScript](https://img.shields.io/badge/TypeScript-ready-blue)
+![License](https://img.shields.io/npm/l/@fagon/ngx-chronox)
 ![Reactive Forms](https://img.shields.io/badge/Reactive%20Forms-Supported-orange)
 ![Standalone Components](https://img.shields.io/badge/Standalone-Compatible-purple)
+![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)
+![Made with Love](https://img.shields.io/badge/made%20with-❤-red)
 
 ## Overview
 
@@ -17,7 +22,7 @@ Built with scalability, accessibility, and maintainability in mind, IntelliToolx
 ### Installation
 
 ```bash
-npm install intellitoolx
+npm intall @fagon/ngx-intellitoolx
 ```
 
 # IntelliToolxHelper
@@ -562,7 +567,7 @@ The component includes built-in messages for common validators:
 | maxMonthYear                  | Date is later than allowed                 |
 | minMonthYear                  | Date is earlier than allowed               |
 | exceededAllowedDateDifference | Date difference can only be one month      |
-| exceededLeastDateAllowed      | Start date cannot be greater than end date |
+| startDateAfterEndDate         | Start date cannot be greater than end date |
 
 ### Adding Control Labels (User-Friendly Messages)
 
@@ -1124,7 +1129,7 @@ These validators return error keys compatible with the error component:
 | passwordMismatchValidator | passwordMismatch |
 | uniqueEmailsValidator     | duplicateEmail   |
 
-Best Practices
+** Best Practices **
 
 - Use with Reactive Forms only
 - Combine with required validators when necessary
@@ -1141,5 +1146,270 @@ this.form = new FormGroup({
 });
 ```
 
-License
-MIT
+# Unsaved Changes Protection
+
+Protect Angular routes and modals from accidental navigation or closing when there are unsaved changes.
+
+Supports:
+
+- Angular route navigation
+- Browser back button
+- Browser refresh / tab close
+- Modal close (NG Bootstrap / Material / custom)
+- Parent + child component setups
+- Nested forms
+
+** The system is built around three core pieces: **
+
+- UnsavedChangesTrackerService
+- UnsavedChangesGuard
+- CanComponentDeactivate interface (for route protection)
+
+** Architecture: **
+
+```
+Form → TrackerService → Guard → Confirmation → Continue / Block
+```
+
+The library does NOT depend on your UI layer.
+Your app controls the confirmation modal.
+
+### Core Exports
+
+```ts
+import { UnsavedChangesTrackerService, UnsavedChangesGuard, CanComponentDeactivate } from "ngx-intellitoolx";
+```
+
+### Protecting Angular Routes
+
+Add Guard to Route
+
+```ts
+{
+	path: 'add-item',
+	component: AddItemPageComponent,
+	canDeactivate: [UnsavedChangesGuard]
+}
+```
+
+### Implement Route Component
+
+Your routed component must implement CanComponentDeactivate.
+
+```ts
+import { UnsavedChangesTrackerService } from "ngx-intellitoolx";
+import { UtilityService } from "../services/utility.service";
+
+@Component({
+  selector: "app-add-item-page",
+  template: `<app-item-form></app-item-form>`,
+})
+export class AddItemPageComponent implements CanComponentDeactivate {
+  constructor(
+    private tracker: UnsavedChangesTrackerService,
+    private utils: UtilityService,
+  ) {}
+
+  confirmUnsavedChanges(): Promise<boolean> {
+    return this.utils.confirmUnsavedChanges();
+  }
+}
+```
+
+### Track Form Changes (Child Component)
+
+```ts
+@Component({
+  selector: "app-item-form",
+  templateUrl: "./item-form.component.html",
+})
+export class ItemFormComponent implements OnInit {
+  form!: FormGroup;
+
+  constructor(
+    private fb: FormBuilder,
+    private tracker: UnsavedChangesTrackerService,
+  ) {}
+
+  ngOnInit(): void {
+    this.form = this.fb.group({
+      name: [""],
+      description: [""],
+    });
+
+    this.tracker.register(this.form);
+  }
+
+  save(): void {
+    // API call
+    this.tracker.markAsPristine();
+    this.form.markAsPristine();
+  }
+}
+```
+
+### Protecting Browser Refresh / Tab Close
+
+Add this inside the routed component:
+
+```ts
+private unregister?: () => void;
+
+constructor(
+    private tracker: FormChangesTrackerService,
+	public utilservice: UtilityService
+  ) {
+    super();
+  }
+
+ngOnInit() {
+	this.unregister = IntelliToolxHelper.registerBeforeUnload(() =>
+      this.tracker.hasChanges(),
+    );
+}
+
+confirmUnsavedChanges(): Promise<boolean> {
+    return this.utilservice.confirmUnsavedChanges();
+  }
+
+ngOnDestroy() {
+	this.unregister?.();
+}
+```
+
+### Protecting Modals (NG Bootstrap Example)
+
+Route guards do NOT protect modals.
+You must intercept modal close manually.
+
+Modal Form Component
+
+```ts
+import { NgbActiveModal } from "@ng-bootstrap/ng-bootstrap";
+import { UnsavedChangesTrackerService } from "ngx-intellitoolx";
+import { UtilityService } from "../utility.service";
+
+@Component({
+  selector: "app-item-modal",
+  templateUrl: "./item-modal.component.html",
+})
+export class ItemModalComponent implements OnInit {
+  form!: FormGroup;
+
+  constructor(
+    private fb: FormBuilder,
+    private tracker: UnsavedChangesTrackerService,
+    private utils: UtilityService,
+    public activeModal: NgbActiveModal,
+  ) {}
+
+  ngOnInit(): void {
+    this.form = this.fb.group({
+      name: [""],
+      description: [""],
+    });
+
+    this.form.valueChanges.subscribe(() => {
+      if (this.form.dirty) {
+        this.tracker.markAsDirty();
+      }
+    });
+  }
+
+  async closeModal() {
+    if (this.tracker.hasChanges()) {
+      const confirmed = await this.utils.confirmUnsavedChanges();
+
+      if (!confirmed) {
+        return; // cancel close
+      }
+    }
+
+    this.activeModal.dismiss();
+  }
+
+  save(): void {
+    this.tracker.markAsPristine();
+    this.form.markAsPristine();
+    this.activeModal.close("saved");
+  }
+}
+```
+
+### Modal Template
+
+```html
+<div class="modal-header">
+  <h5 class="modal-title">Add Item</h5>
+  <button type="button" class="btn-close" (click)="closeModal()"></button>
+</div>
+
+<div class="modal-body">
+  <form [formGroup]="form">
+    <input formControlName="name" />
+    <textarea formControlName="description"></textarea>
+  </form>
+</div>
+
+<div class="modal-footer">
+  <button class="btn btn-secondary" (click)="closeModal()">Cancel</button>
+
+  <button class="btn btn-primary" (click)="save()">Save</button>
+</div>
+```
+
+** How It Works **
+
+| Action               | What Happens          |
+| -------------------- | --------------------- |
+| User edits form      | Tracker marks dirty   |
+| User navigates route | Guard checks tracker  |
+| User refreshes page  | beforeunload triggers |
+| User closes modal    | Manual interception   |
+| User saves form      | Tracker resets        |
+
+** Parent + Child Structure **
+
+If your form is nested:
+
+```
+RouteComponent
+└── Modal
+└── Form
+
+Child form → marks tracker dirty
+
+Route component → implements guard interface
+
+Modal → manually checks tracker before close
+```
+
+** Best Practices **
+
+- Always call markAsPristine() after successful save
+- Always intercept modal close
+- Keep confirmation UI inside the consuming app
+- Do not couple library to UI services
+
+** Confirmation Modal Example (App Layer) **
+
+```ts
+@Injectable({ providedIn: "root" })
+export class UtilityService {
+  constructor(private modal: NgbModal) {}
+
+  confirmUnsavedChanges(): Promise<boolean> {
+    const modalRef = this.modal.open(UnsavedConfirmComponent, {
+      backdrop: "static",
+    });
+
+    return modalRef.result.then(() => true).catch(() => false);
+  }
+}
+```
+
+📄 License
+
+```
+MIT © Fagon Technologies
+```

package/esm2022/lib/form-changes/can-component-deactivate.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FuLWNvbXBvbmVudC1kZWFjdGl2YXRlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvZm9ybS1jaGFuZ2VzL2Nhbi1jb21wb25lbnQtZGVhY3RpdmF0ZS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2FuQ29tcG9uZW50RGVhY3RpdmF0ZSB7XG4gIGhhc1Vuc2F2ZWRDaGFuZ2VzOiAoKSA9PiBib29sZWFuO1xuICBjb25maXJtVW5zYXZlZENoYW5nZXM/OiAoKSA9PiBQcm9taXNlPGJvb2xlYW4+IHwgYm9vbGVhbjtcbiAgZ2V0VW5zYXZlZE1lc3NhZ2U/OiAoKSA9PiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/form-changes/confirm-handler.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlybS1oYW5kbGVyLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2Zvcm0tY2hhbmdlcy9jb25maXJtLWhhbmRsZXIudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgQ29uZmlybUhhbmRsZXIgPSAoKSA9PiBib29sZWFuIHwgUHJvbWlzZTxib29sZWFuPjtcbiJdfQ==

package/esm2022/lib/form-changes/form-changes-tracker.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { IntelliToolxHelper } from '../helpers/intellitoolx.helper';
+import * as i0 from "@angular/core";
+export class FormChangesTrackerService {
+    constructor() {
+        this.trackedForms = new Map();
+    }
+    register(form) {
+        const currentRawValue = form.getRawValue?.() ?? form.value;
+        this.trackedForms.set(form, {
+            initialValue: IntelliToolxHelper.clone(currentRawValue),
+        });
+        form.markAsPristine();
+    }
+    hasChanges() {
+        // We iterate over entries [form, metadata]
+        for (const [form, { initialValue }] of this.trackedForms.entries()) {
+            if (IntelliToolxHelper.formHasChanges(initialValue, form)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    unregister(form) {
+        this.trackedForms.delete(form);
+    }
+    reset(form) {
+        const entry = this.trackedForms.get(form);
+        if (!entry)
+            return;
+        const currentRawValue = form.getRawValue?.() ?? form.value;
+        entry.initialValue = IntelliToolxHelper.clone(currentRawValue);
+        form.markAsPristine();
+    }
+    clearAll() {
+        this.trackedForms.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormChangesTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormChangesTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormChangesTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form-changes/form-update-message-config.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS11cGRhdGUtbWVzc2FnZS1jb25maWcuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9mb3JtLWNoYW5nZXMvZm9ybS11cGRhdGUtbWVzc2FnZS1jb25maWcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEludGVsbGl0b29seEZvcm1VcGRhdGVNZXNzYWdlQ29uZmlnIHtcbiAgbWVzc2FnZT86IHN0cmluZztcbiAgYmFja2dyb3VuZENvbG9yPzogc3RyaW5nO1xuICB0ZXh0Q29sb3I/OiBzdHJpbmc7XG4gIGJvcmRlckNvbG9yPzogc3RyaW5nO1xuICBmb250V2VpZ2h0PzogbnVtYmVyO1xuICBib3JkZXJSYWRpdXM/OiBzdHJpbmc7XG4gIHBhZGRpbmc/OiBzdHJpbmc7XG4gIGljb25BbmRNZXNzYWdlR2FwPzogc3RyaW5nO1xuICBpY29uU2l6ZT86IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/lib/form-changes/form-update-message.component.mjs

@@ -0,0 +1,53 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class IntellitoolxFormUpdateMessage {
+    constructor() {
+        this.defaultMessage = 'There are no changes to save. Please modify a field to continue.';
+    }
+    get containerStyles() {
+        return {
+            padding: this.itxFormUpdateMessageConfig?.padding || '1rem',
+            gap: this.itxFormUpdateMessageConfig?.iconAndMessageGap || '0.5rem',
+            color: this.itxFormUpdateMessageConfig?.textColor || '#963C00',
+            border: '1px solid ' +
+                (this.itxFormUpdateMessageConfig?.borderColor || '#f3cd5a'),
+            'background-color': this.itxFormUpdateMessageConfig?.backgroundColor || '#fff3cd',
+            'font-weight': String(this.itxFormUpdateMessageConfig?.fontWeight || 400),
+            'border-radius': this.itxFormUpdateMessageConfig?.borderRadius || '0.5rem',
+        };
+    }
+    get iconStyles() {
+        return {
+            'font-size': this.itxFormUpdateMessageConfig?.iconSize || '1rem',
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormUpdateMessage, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: IntellitoolxFormUpdateMessage, isStandalone: true, selector: "itx-form-update-message", inputs: { itxFormUpdateMessageConfig: "itxFormUpdateMessageConfig" }, ngImport: i0, template: `
+    <div class="form-update-message" role="alert" [ngStyle]="containerStyles">
+      <span class="form-update-icon" aria-hidden="true" [ngStyle]="iconStyles"
+        >⚠</span
+      >
+      <span>
+        {{ itxFormUpdateMessageConfig?.message || defaultMessage }}
+      </span>
+    </div>
+  `, isInline: true, styles: [".form-update-message{display:flex;margin-top:.5rem}.form-update-icon{flex-shrink:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormUpdateMessage, decorators: [{
+            type: Component,
+            args: [{ selector: 'itx-form-update-message', standalone: true, imports: [CommonModule], template: `
+    <div class="form-update-message" role="alert" [ngStyle]="containerStyles">
+      <span class="form-update-icon" aria-hidden="true" [ngStyle]="iconStyles"
+        >⚠</span
+      >
+      <span>
+        {{ itxFormUpdateMessageConfig?.message || defaultMessage }}
+      </span>
+    </div>
+  `, styles: [".form-update-message{display:flex;margin-top:.5rem}.form-update-icon{flex-shrink:0}\n"] }]
+        }], propDecorators: { itxFormUpdateMessageConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form-changes/unsaved-changes.guard.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./form-changes-tracker.service";
+export class UnsavedChangesGuard {
+    constructor(tracker) {
+        this.tracker = tracker;
+    }
+    async canDeactivate(component) {
+        if (!this.tracker.hasChanges()) {
+            return true;
+        }
+        // Component provides its own confirmation (modal)
+        if (component.confirmUnsavedChanges) {
+            const result = component.confirmUnsavedChanges();
+            return typeof result === 'boolean' ? result : await result;
+        }
+        const message = component.getUnsavedMessage?.() ||
+            'You have unsaved changes. Leave without saving?';
+        // Fallback browser confirm
+        return confirm(message);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, deps: [{ token: i1.FormChangesTrackerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.FormChangesTrackerService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form-errors/form-errors.component.mjs

@@ -16,7 +16,7 @@ export class IntellitoolxFormErrors {
             passwordMismatch: 'Password and confirm password do not match.',
             futureDate: 'Future date is not allowed.',
             exceededAllowedDateDifference: 'Date difference can only be one month.',
-            exceededLeastDateAllowed: 'Start date cannot be greater than end date',
+            startDateAfterEndDate: 'Start date cannot be greater than end date',
             duplicateEmail: 'Each email must be unique.',
             maxWords: 'Exceeded maximum number of words.',
             maxMonthYear: 'Date is later than allowed.',
@@ -69,7 +69,7 @@ export class IntellitoolxFormErrors {
                 case 'maxMonthYear':
                 case 'minMonthYear':
                 case 'exceededAllowedDateDifference':
-                case 'exceededLeastDateAllowed':
+                case 'startDateAfterEndDate':
                     return customMessage || this.errorMessages[key];
                 default:
                     return customMessage || '';
@@ -107,4 +107,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], controlLabel: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-errors.component.js","sourceRoot":"","sources":["../../../../src/lib/form-errors/form-errors.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input } from '@angular/core';\nimport {\n  AbstractControl,\n  FormControl,\n  UntypedFormControl,\n} from '@angular/forms';\n\nexport interface ErrorMessages {\n  [key: string]: string;\n  required: string;\n  email: string;\n  minlength: string;\n  maxlength: string;\n  pattern: string;\n  passwordMismatch: string;\n  futureDate: string;\n  exceededAllowedDateDifference: string;\n  exceededLeastDateAllowed: string;\n  duplicateEmail: string;\n  maxWords: string;\n  maxMonthYear: string;\n  minMonthYear: string;\n}\n\n@Component({\n  selector: 'itx-form-errors',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <ng-container *ngIf=\"control?.touched && control?.invalid\">\n      <ng-container *ngFor=\"let error of control?.errors | keyvalue\">\n        {{ getErrorMessage(error?.key ?? '', error?.value) }}\n      </ng-container>\n    </ng-container>\n  `,\n})\nexport class IntellitoolxFormErrors {\n  @Input() control: FormControl | UntypedFormControl | AbstractControl | null =\n    null;\n  @Input() componentValidation: Record<string, { message: string }> = {};\n  @Input() controlLabel: string | null = null;\n\n  errorMessages: ErrorMessages = {\n    required: 'This field is required',\n    email: 'The email entered is invalid',\n    minlength: 'You must enter at least {length} characters',\n    maxlength: 'You must not enter more than {length} characters',\n    pattern: 'Your entry must match the required pattern',\n    passwordMismatch: 'Password and confirm password do not match.',\n    futureDate: 'Future date is not allowed.',\n    exceededAllowedDateDifference: 'Date difference can only be one month.',\n    exceededLeastDateAllowed: 'Start date cannot be greater than end date',\n    duplicateEmail: 'Each email must be unique.',\n    maxWords: 'Exceeded maximum number of words.',\n    maxMonthYear: 'Date is later than allowed.',\n    minMonthYear: 'Date is earlier than allowed.',\n  };\n\n  getErrorMessage(key: string, value: any): string {\n    if (!this.control) return '';\n\n    const customMessage = this.componentValidation?.[key]?.message;\n\n    if (typeof value === 'boolean') {\n      return customMessage || this.errorMessages[key] || '';\n    }\n\n    if (typeof value === 'string') {\n      return customMessage || value;\n    }\n\n    if (typeof value === 'object') {\n      switch (key) {\n        case 'pattern':\n          return (\n            customMessage ||\n            `Please provide a valid ${this.controlLabel || 'data'}.`\n          );\n        case 'min':\n          return customMessage\n            ? customMessage\n            : this.controlLabel\n              ? `${this.controlLabel} cannot be less than ${value.min}.`\n              : `Number cannot be less than ${value.min}`;\n        case 'max':\n          return customMessage\n            ? customMessage\n            : this.controlLabel\n              ? `${this.controlLabel} cannot be greater than ${value.max}.`\n              : `Number cannot be greater than ${value.max}`;\n        case 'minlength':\n          return (\n            customMessage ||\n            this.errorMessages.minlength.replace(\n              '{length}',\n              value?.requiredLength || '',\n            )\n          );\n        case 'maxlength':\n          return (\n            customMessage ||\n            this.errorMessages.maxlength.replace(\n              '{length}',\n              value?.requiredLength || '',\n            )\n          );\n        case 'customMinValue':\n        case 'customMaxValue':\n          return customMessage || value?.message || '';\n        case 'ngbDate':\n          return (\n            customMessage ||\n            (this.control.value ? 'Invalid date format provided' : '')\n          );\n        case 'passwordMismatch':\n        case 'futureDate':\n        case 'duplicateEmail':\n        case 'maxWords':\n        case 'maxMonthYear':\n        case 'minMonthYear':\n        case 'exceededAllowedDateDifference':\n        case 'exceededLeastDateAllowed':\n          return customMessage || this.errorMessages[key];\n        default:\n          return customMessage || '';\n      }\n    }\n\n    return '';\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-errors.component.js","sourceRoot":"","sources":["../../../../src/lib/form-errors/form-errors.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input } from '@angular/core';\nimport {\n  AbstractControl,\n  FormControl,\n  UntypedFormControl,\n} from '@angular/forms';\n\nexport interface ErrorMessages {\n  [key: string]: string;\n  required: string;\n  email: string;\n  minlength: string;\n  maxlength: string;\n  pattern: string;\n  passwordMismatch: string;\n  futureDate: string;\n  exceededAllowedDateDifference: string;\n  startDateAfterEndDate: string;\n  duplicateEmail: string;\n  maxWords: string;\n  maxMonthYear: string;\n  minMonthYear: string;\n}\n\n@Component({\n  selector: 'itx-form-errors',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <ng-container *ngIf=\"control?.touched && control?.invalid\">\n      <ng-container *ngFor=\"let error of control?.errors | keyvalue\">\n        {{ getErrorMessage(error?.key ?? '', error?.value) }}\n      </ng-container>\n    </ng-container>\n  `,\n})\nexport class IntellitoolxFormErrors {\n  @Input() control: FormControl | UntypedFormControl | AbstractControl | null =\n    null;\n  @Input() componentValidation: Record<string, { message: string }> = {};\n  @Input() controlLabel: string | null = null;\n\n  errorMessages: ErrorMessages = {\n    required: 'This field is required',\n    email: 'The email entered is invalid',\n    minlength: 'You must enter at least {length} characters',\n    maxlength: 'You must not enter more than {length} characters',\n    pattern: 'Your entry must match the required pattern',\n    passwordMismatch: 'Password and confirm password do not match.',\n    futureDate: 'Future date is not allowed.',\n    exceededAllowedDateDifference: 'Date difference can only be one month.',\n    startDateAfterEndDate: 'Start date cannot be greater than end date',\n    duplicateEmail: 'Each email must be unique.',\n    maxWords: 'Exceeded maximum number of words.',\n    maxMonthYear: 'Date is later than allowed.',\n    minMonthYear: 'Date is earlier than allowed.',\n  };\n\n  getErrorMessage(key: string, value: any): string {\n    if (!this.control) return '';\n\n    const customMessage = this.componentValidation?.[key]?.message;\n\n    if (typeof value === 'boolean') {\n      return customMessage || this.errorMessages[key] || '';\n    }\n\n    if (typeof value === 'string') {\n      return customMessage || value;\n    }\n\n    if (typeof value === 'object') {\n      switch (key) {\n        case 'pattern':\n          return (\n            customMessage ||\n            `Please provide a valid ${this.controlLabel || 'data'}.`\n          );\n        case 'min':\n          return customMessage\n            ? customMessage\n            : this.controlLabel\n              ? `${this.controlLabel} cannot be less than ${value.min}.`\n              : `Number cannot be less than ${value.min}`;\n        case 'max':\n          return customMessage\n            ? customMessage\n            : this.controlLabel\n              ? `${this.controlLabel} cannot be greater than ${value.max}.`\n              : `Number cannot be greater than ${value.max}`;\n        case 'minlength':\n          return (\n            customMessage ||\n            this.errorMessages.minlength.replace(\n              '{length}',\n              value?.requiredLength || '',\n            )\n          );\n        case 'maxlength':\n          return (\n            customMessage ||\n            this.errorMessages.maxlength.replace(\n              '{length}',\n              value?.requiredLength || '',\n            )\n          );\n        case 'customMinValue':\n        case 'customMaxValue':\n          return customMessage || value?.message || '';\n        case 'ngbDate':\n          return (\n            customMessage ||\n            (this.control.value ? 'Invalid date format provided' : '')\n          );\n        case 'passwordMismatch':\n        case 'futureDate':\n        case 'duplicateEmail':\n        case 'maxWords':\n        case 'maxMonthYear':\n        case 'minMonthYear':\n        case 'exceededAllowedDateDifference':\n        case 'startDateAfterEndDate':\n          return customMessage || this.errorMessages[key];\n        default:\n          return customMessage || '';\n      }\n    }\n\n    return '';\n  }\n}\n"]}

package/esm2022/lib/helpers/intellitoolx.helper.mjs

@@ -86,7 +86,6 @@ export class IntelliToolxHelper {
             const result = confirmHandler();
             return typeof result === 'boolean' ? result : await result;
         }
-        // fallback (only if handler not provided)
         return confirm('You have unsaved changes. Continue?');
     }
     static registerBeforeUnload(shouldBlock, message) {
@@ -94,7 +93,7 @@ export class IntelliToolxHelper {
             if (!shouldBlock())
                 return;
             event.preventDefault();
-            event.returnValue = message || '';
+            event.returnValue = message ?? '';
         };
         window.addEventListener('beforeunload', handler);
         return () => window.removeEventListener('beforeunload', handler);
@@ -153,4 +152,4 @@ export class IntelliToolxHelper {
         return value;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intellitoolx.helper.js","sourceRoot":"","sources":["../../../../src/lib/helpers/intellitoolx.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AbstractControl,\n  FormArray,\n  FormControl,\n  FormGroup,\n} from '@angular/forms';\nimport { ConfirmHandler } from '../form-update/confirm-handler.type';\n\nexport class IntelliToolxHelper {\n  static captureInitialFormValue(form: AbstractControl): any {\n    const initialValue = (form as any).getRawValue?.() ?? form.value;\n    form.markAsPristine();\n    return this.clone(initialValue);\n  }\n\n  static trimFormGroup(control: AbstractControl): void {\n    if (control instanceof FormGroup) {\n      Object.keys(control.controls).forEach((key) =>\n        this.trimFormGroup(control.controls[key]),\n      );\n      return;\n    }\n\n    if (control instanceof FormArray) {\n      control.controls.forEach((ctrl) => this.trimFormGroup(ctrl));\n      return;\n    }\n\n    if (control instanceof FormControl) {\n      const value = control.value;\n      if (typeof value === 'string') {\n        control.setValue(value.trim(), { emitEvent: false });\n      }\n    }\n  }\n\n  static deepEqual(obj1: any, obj2: any): boolean {\n    // treat null, undefined, and empty string as equal\n    if (this.isEmpty(obj1) && this.isEmpty(obj2)) {\n      return true;\n    }\n\n    // normalize numeric values\n    if (typeof obj1 === 'number' && typeof obj2 === 'number') {\n      return Number(obj1) === Number(obj2);\n    }\n\n    // strict equality shortcut\n    if (obj1 === obj2) return true;\n\n    // File comparison\n    if (obj1 instanceof File && obj2 instanceof File) {\n      return (\n        obj1.name === obj2.name &&\n        obj1.size === obj2.size &&\n        obj1.type === obj2.type &&\n        obj1.lastModified === obj2.lastModified\n      );\n    }\n\n    // if not objects → not equal\n    if (\n      typeof obj1 !== 'object' ||\n      typeof obj2 !== 'object' ||\n      obj1 === null ||\n      obj2 === null\n    ) {\n      return false;\n    }\n\n    // arrays\n    if (Array.isArray(obj1) && Array.isArray(obj2)) {\n      if (obj1.length !== obj2.length) return false;\n      return obj1.every((v, i) => this.deepEqual(v, obj2[i]));\n    }\n\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n\n    if (keys1.length !== keys2.length) return false;\n\n    for (const key of keys1) {\n      if (!keys2.includes(key)) return false;\n      if (!this.deepEqual(obj1[key], obj2[key])) return false;\n    }\n\n    return true;\n  }\n\n  static isEmpty(value: any): boolean {\n    return (\n      value === null ||\n      value === undefined ||\n      (typeof value === 'string' && value.trim() === '')\n    );\n  }\n\n  static clone(value: any): any {\n    return structuredClone(value); // Angular 14+ safe\n  }\n\n  static formHasChanges(initialValue: any, form: AbstractControl): boolean {\n    if (!form) return false;\n\n    const current = form.getRawValue();\n    return !this.deepEqual(initialValue, current);\n  }\n\n  static async confirmIfChanged(\n    hasChanges: boolean,\n    confirmHandler?: ConfirmHandler,\n  ): Promise<boolean> {\n    if (!hasChanges) return true;\n\n    if (confirmHandler) {\n      const result = confirmHandler();\n      return typeof result === 'boolean' ? result : await result;\n    }\n\n    // fallback (only if handler not provided)\n    return confirm('You have unsaved changes. Continue?');\n  }\n\n  static registerBeforeUnload(shouldBlock: () => boolean, message?: string) {\n    const handler = (event: BeforeUnloadEvent) => {\n      if (!shouldBlock()) return;\n\n      event.preventDefault();\n      event.returnValue = message || '';\n    };\n\n    window.addEventListener('beforeunload', handler);\n\n    return () => window.removeEventListener('beforeunload', handler);\n  }\n\n  static getFormControl<T = any>(\n    form: AbstractControl,\n    path: string,\n  ): FormControl<T> | null {\n    if (!form || !path) return null;\n\n    const segments = path.split('.');\n    let current: AbstractControl | null = form;\n\n    for (const segment of segments) {\n      if (!current) return null;\n\n      // Treat numeric segment as FormArray index\n      const index = Number(segment);\n      if (!isNaN(index) && current instanceof FormArray) {\n        current = current.at(index);\n      } else if (current instanceof FormGroup) {\n        current = current.get(segment);\n      } else {\n        return null;\n      }\n    }\n\n    return current instanceof FormControl ? (current as FormControl<T>) : null;\n  }\n\n  static convertImageToBase64(file: File): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      const reader = new FileReader();\n\n      reader.readAsDataURL(file);\n\n      reader.onload = () => {\n        const base64String = reader.result as string;\n        const base64StringArray = base64String.split(',');\n        resolve(base64StringArray[1]);\n      };\n\n      reader.onerror = (error) => {\n        reject(error);\n      };\n    });\n  }\n\n  static replaceCharacter(\n    text: any,\n    replaceChar: string,\n    replaceWithChar: string,\n  ): string {\n    return text?.replaceAll(replaceChar, replaceWithChar) || '';\n  }\n\n  static convertJsonStringToJson<T = any>(\n    value: T | string | null | undefined,\n  ): T | null {\n    if (!value) {\n      return null;\n    }\n\n    if (typeof value === 'string') {\n      try {\n        return JSON.parse(value) as T;\n      } catch {\n        return null;\n      }\n    }\n\n    return value as T;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intellitoolx.helper.js","sourceRoot":"","sources":["../../../../src/lib/helpers/intellitoolx.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AbstractControl,\n  FormArray,\n  FormControl,\n  FormGroup,\n} from '@angular/forms';\nimport { ConfirmHandler } from '../form-changes/confirm-handler.type';\n\nexport class IntelliToolxHelper {\n  static captureInitialFormValue(form: AbstractControl): any {\n    const initialValue = (form as any).getRawValue?.() ?? form.value;\n    form.markAsPristine();\n    return this.clone(initialValue);\n  }\n\n  static trimFormGroup(control: AbstractControl): void {\n    if (control instanceof FormGroup) {\n      Object.keys(control.controls).forEach((key) =>\n        this.trimFormGroup(control.controls[key]),\n      );\n      return;\n    }\n\n    if (control instanceof FormArray) {\n      control.controls.forEach((ctrl) => this.trimFormGroup(ctrl));\n      return;\n    }\n\n    if (control instanceof FormControl) {\n      const value = control.value;\n      if (typeof value === 'string') {\n        control.setValue(value.trim(), { emitEvent: false });\n      }\n    }\n  }\n\n  static deepEqual(obj1: any, obj2: any): boolean {\n    // treat null, undefined, and empty string as equal\n    if (this.isEmpty(obj1) && this.isEmpty(obj2)) {\n      return true;\n    }\n\n    // normalize numeric values\n    if (typeof obj1 === 'number' && typeof obj2 === 'number') {\n      return Number(obj1) === Number(obj2);\n    }\n\n    // strict equality shortcut\n    if (obj1 === obj2) return true;\n\n    // File comparison\n    if (obj1 instanceof File && obj2 instanceof File) {\n      return (\n        obj1.name === obj2.name &&\n        obj1.size === obj2.size &&\n        obj1.type === obj2.type &&\n        obj1.lastModified === obj2.lastModified\n      );\n    }\n\n    // if not objects → not equal\n    if (\n      typeof obj1 !== 'object' ||\n      typeof obj2 !== 'object' ||\n      obj1 === null ||\n      obj2 === null\n    ) {\n      return false;\n    }\n\n    // arrays\n    if (Array.isArray(obj1) && Array.isArray(obj2)) {\n      if (obj1.length !== obj2.length) return false;\n      return obj1.every((v, i) => this.deepEqual(v, obj2[i]));\n    }\n\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n\n    if (keys1.length !== keys2.length) return false;\n\n    for (const key of keys1) {\n      if (!keys2.includes(key)) return false;\n      if (!this.deepEqual(obj1[key], obj2[key])) return false;\n    }\n\n    return true;\n  }\n\n  static isEmpty(value: any): boolean {\n    return (\n      value === null ||\n      value === undefined ||\n      (typeof value === 'string' && value.trim() === '')\n    );\n  }\n\n  static clone(value: any): any {\n    return structuredClone(value); // Angular 14+ safe\n  }\n\n  static formHasChanges(initialValue: any, form: AbstractControl): boolean {\n    if (!form) return false;\n\n    const current = form.getRawValue();\n    return !this.deepEqual(initialValue, current);\n  }\n\n  static async confirmIfChanged(\n    hasChanges: boolean,\n    confirmHandler?: ConfirmHandler,\n  ): Promise<boolean> {\n    if (!hasChanges) return true;\n\n    if (confirmHandler) {\n      const result = confirmHandler();\n      return typeof result === 'boolean' ? result : await result;\n    }\n\n    return confirm('You have unsaved changes. Continue?');\n  }\n\n  static registerBeforeUnload(shouldBlock: () => boolean, message?: string) {\n    const handler = (event: BeforeUnloadEvent) => {\n      if (!shouldBlock()) return;\n      event.preventDefault();\n      event.returnValue = message ?? '';\n    };\n\n    window.addEventListener('beforeunload', handler);\n    return () => window.removeEventListener('beforeunload', handler);\n  }\n\n  static getFormControl<T = any>(\n    form: AbstractControl,\n    path: string,\n  ): FormControl<T> | null {\n    if (!form || !path) return null;\n\n    const segments = path.split('.');\n    let current: AbstractControl | null = form;\n\n    for (const segment of segments) {\n      if (!current) return null;\n\n      // Treat numeric segment as FormArray index\n      const index = Number(segment);\n      if (!isNaN(index) && current instanceof FormArray) {\n        current = current.at(index);\n      } else if (current instanceof FormGroup) {\n        current = current.get(segment);\n      } else {\n        return null;\n      }\n    }\n\n    return current instanceof FormControl ? (current as FormControl<T>) : null;\n  }\n\n  static convertImageToBase64(file: File): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      const reader = new FileReader();\n\n      reader.readAsDataURL(file);\n\n      reader.onload = () => {\n        const base64String = reader.result as string;\n        const base64StringArray = base64String.split(',');\n        resolve(base64StringArray[1]);\n      };\n\n      reader.onerror = (error) => {\n        reject(error);\n      };\n    });\n  }\n\n  static replaceCharacter(\n    text: any,\n    replaceChar: string,\n    replaceWithChar: string,\n  ): string {\n    return text?.replaceAll(replaceChar, replaceWithChar) || '';\n  }\n\n  static convertJsonStringToJson<T = any>(\n    value: T | string | null | undefined,\n  ): T | null {\n    if (!value) {\n      return null;\n    }\n\n    if (typeof value === 'string') {\n      try {\n        return JSON.parse(value) as T;\n      } catch {\n        return null;\n      }\n    }\n\n    return value as T;\n  }\n}\n"]}