@fagon/ngx-intellitoolx 16.0.4 → 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/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"]}

package/esm2022/public-api.mjs

@@ -1,27 +1,28 @@
 /*
  * Public API Surface of ngx-intellitoolx
  */
-// Moddules
-export * from './lib/ngx-intellitoolx.module';
+// Form Changes
+export * from './lib/form-changes/form-changes-tracker.service';
+export * from './lib/form-changes/form-update-message.component';
+export * from './lib/form-changes/unsaved-changes.guard';
+export * from './lib/form-changes/can-component-deactivate.interface';
+export * from './lib/form-changes/form-update-message-config.interface';
+// Form validation
+export * from './lib/form-errors/form-errors.component';
+export * from './lib/directives/required-marker/required-marker.directive';
+export * from './lib/directives/required-marker/required-marker.config';
+export * from './lib/directives/required-marker/required-marker.token';
+export * from './lib/directives/required-marker/required-marker.defaults';
 // Helpers
 export * from './lib/helpers/intellitoolx.helper';
 // Pipes
 export * from './lib/pipes/json-parse.pipe';
 // Components
 export * from './lib/ngx-intellitoolx.component';
-export * from './lib/form-update/form-update-message.component';
-export * from './lib/form-errors/form-errors.component';
 // Validators
 export * from './lib/form-validators';
 // Regular expressions
 export * from './lib/regex/regex.utils';
-// Models/Interfaces
-export * from './lib/form-update/form-update-message-config.interface';
-//  Required marker directive
-export * from './lib/directives/required-marker/required-marker.directive';
-export * from './lib/directives/required-marker/required-marker.config';
-export * from './lib/directives/required-marker/required-marker.token';
-export * from './lib/directives/required-marker/required-marker.defaults';
-// Guards
-export * from './lib/form-update/unsaved-changes.guard';
-//# sourceMappingURL=data:application/json;base64,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
+// Moddules
+export * from './lib/ngx-intellitoolx.module';
+//# sourceMappingURL=data:application/json;base64,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