@qbs-origin/origin-form 0.5.0

package/esm2022/lib/services/scroll-to-error.service.mjs

@@ -0,0 +1,369 @@
+import { Injectable } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class ScrollToErrorService {
+    /**
+     * Scroll to the first validation error in a form
+     */
+    scrollToFirstError(form) {
+        try {
+            // Find the first invalid control
+            const firstInvalidControl = this.findFirstInvalidControl(form);
+            if (firstInvalidControl) {
+                this.scrollToField(firstInvalidControl.name);
+            }
+        }
+        catch (error) {
+            console.error('Error scrolling to first error:', error);
+        }
+    }
+    /**
+     * Scroll to a specific field by name
+     */
+    scrollToField(fieldName) {
+        // Add a small delay to ensure DOM is ready
+        setTimeout(() => {
+            const element = this.findFormFieldElement(fieldName);
+            if (element) {
+                this.scrollToElement(element);
+            }
+            else {
+                this.tryFindMatchingInvalidField(fieldName);
+            }
+        }, 100);
+    }
+    /**
+     * Find first invalid control in form
+     */
+    findFirstInvalidControl(formGroup, parentName = '') {
+        for (const controlName in formGroup.controls) {
+            const control = formGroup.controls[controlName];
+            const fullControlName = parentName ? `${parentName}.${controlName}` : controlName;
+            if (control instanceof FormGroup) {
+                const nestedInvalid = this.findFirstInvalidControl(control, fullControlName);
+                if (nestedInvalid) {
+                    return nestedInvalid;
+                }
+            }
+            else {
+                // Check if this control is invalid
+                if (control.invalid && (control.dirty || control.touched)) {
+                    return { name: fullControlName, control };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Find form field element by various selectors
+     */
+    findFormFieldElement(fieldName) {
+        if (!fieldName)
+            return null;
+        // Clean the field name for better matching
+        const cleanFieldName = fieldName.replace(/[.\[\]]/g, '');
+        // Try various selectors to find the form field
+        const selectors = [
+            // Formly specific selectors
+            `formly-field[ng-reflect-field*="${fieldName}"]`,
+            `formly-field[ng-reflect-field*="${cleanFieldName}"]`,
+            `[data-cy="${fieldName}"]`,
+            `[data-cy="${cleanFieldName}"]`,
+            // Form control selectors
+            `input[formcontrolname="${fieldName}"]`,
+            `select[formcontrolname="${fieldName}"]`,
+            `textarea[formcontrolname="${fieldName}"]`,
+            `input[formcontrolname="${cleanFieldName}"]`,
+            `select[formcontrolname="${cleanFieldName}"]`,
+            `textarea[formcontrolname="${cleanFieldName}"]`,
+            // Name and ID selectors
+            `input[name="${fieldName}"]`,
+            `select[name="${fieldName}"]`,
+            `textarea[name="${fieldName}"]`,
+            `#${fieldName}`,
+            `#${cleanFieldName}`,
+            // Class selectors
+            `.field-${fieldName}`,
+            `.field-${cleanFieldName}`,
+            // Angular Material specific
+            `mat-form-field:has(input[formcontrolname="${fieldName}"])`,
+            `mat-form-field:has(select[formcontrolname="${fieldName}"])`,
+            `mat-form-field:has(textarea[formcontrolname="${fieldName}"])`,
+            // Generic error class selectors
+            `.ng-invalid[formcontrolname="${fieldName}"]`,
+            `.ng-invalid[name="${fieldName}"]`,
+            // Broader searches
+            `[ng-reflect-name="${fieldName}"]`,
+            `[ng-reflect-key="${fieldName}"]`
+        ];
+        for (const selector of selectors) {
+            try {
+                const element = document.querySelector(selector);
+                if (element && this.isElementVisible(element)) {
+                    return element;
+                }
+            }
+            catch (error) {
+                // Some selectors might be invalid, continue trying others
+                continue;
+            }
+        }
+        // Fallback: search through all elements
+        return this.fallbackElementSearch(fieldName, cleanFieldName);
+    }
+    /**
+     * Fallback search through all elements
+     */
+    fallbackElementSearch(fieldName, cleanFieldName) {
+        const allElements = document.querySelectorAll('input, select, textarea, formly-field, mat-form-field');
+        for (const element of Array.from(allElements)) {
+            const htmlElement = element;
+            // Check various attributes
+            const attributes = [
+                'formcontrolname',
+                'name',
+                'id',
+                'ng-reflect-name',
+                'ng-reflect-key',
+                'data-cy'
+            ];
+            for (const attr of attributes) {
+                const attrValue = htmlElement.getAttribute(attr);
+                if (attrValue === fieldName || attrValue === cleanFieldName) {
+                    if (this.isElementVisible(htmlElement)) {
+                        return htmlElement;
+                    }
+                }
+            }
+            // Check class names
+            if (htmlElement.classList.contains(`field-${fieldName}`) ||
+                htmlElement.classList.contains(`field-${cleanFieldName}`)) {
+                if (this.isElementVisible(htmlElement)) {
+                    return htmlElement;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if element is visible
+     */
+    isElementVisible(element) {
+        const rect = element.getBoundingClientRect();
+        const style = window.getComputedStyle(element);
+        return rect.width > 0 &&
+            rect.height > 0 &&
+            style.visibility !== 'hidden' &&
+            style.display !== 'none' &&
+            style.opacity !== '0';
+    }
+    /**
+     * Try to find a matching invalid field when direct search fails
+     */
+    tryFindMatchingInvalidField(fieldName) {
+        const cleanFieldName = fieldName.replace(/[.\[\]]/g, '');
+        // Get all invalid elements
+        const invalidElements = document.querySelectorAll('.ng-invalid');
+        // Try to find one that matches our field name
+        for (const element of Array.from(invalidElements)) {
+            const htmlElement = element;
+            // Check if this invalid element matches our field
+            const attributes = ['formcontrolname', 'name', 'id', 'ng-reflect-name', 'ng-reflect-key'];
+            for (const attr of attributes) {
+                const attrValue = htmlElement.getAttribute(attr);
+                if (attrValue === fieldName || attrValue === cleanFieldName) {
+                    if (this.isElementVisible(htmlElement)) {
+                        this.scrollToElement(htmlElement);
+                        return;
+                    }
+                }
+            }
+            // Check for partial matches in IDs (formly generates IDs with field names)
+            const id = htmlElement.getAttribute('id');
+            if (id && (id.includes(fieldName) || id.includes(cleanFieldName))) {
+                if (this.isElementVisible(htmlElement)) {
+                    this.scrollToElement(htmlElement);
+                    return;
+                }
+            }
+        }
+        // If no matching invalid element found, try formly field containers
+        this.tryFindFormlyFieldContainer(fieldName, cleanFieldName);
+    }
+    /**
+     * Try to find formly field container and look for invalid elements within it
+     */
+    tryFindFormlyFieldContainer(fieldName, cleanFieldName) {
+        const formlyFields = document.querySelectorAll('formly-field');
+        for (const formlyField of Array.from(formlyFields)) {
+            const fieldElement = formlyField;
+            // Check if this formly field's ng-reflect-field contains our field name
+            const ngReflectField = fieldElement.getAttribute('ng-reflect-field');
+            if (ngReflectField &&
+                (ngReflectField.includes(`"key":"${fieldName}"`) ||
+                    ngReflectField.includes(`"key":"${cleanFieldName}"`))) {
+                // Look for invalid elements within this container
+                const invalidInContainer = fieldElement.querySelector('.ng-invalid');
+                if (invalidInContainer && this.isElementVisible(invalidInContainer)) {
+                    this.scrollToElement(invalidInContainer);
+                    return;
+                }
+                // If no invalid element, scroll to the container itself
+                if (this.isElementVisible(fieldElement)) {
+                    this.scrollToElement(fieldElement);
+                    return;
+                }
+            }
+        }
+        // Last resort: scroll to first visible invalid element
+        const invalidElements = document.querySelectorAll('.ng-invalid');
+        for (const element of Array.from(invalidElements)) {
+            const htmlElement = element;
+            if (this.isElementVisible(htmlElement)) {
+                this.scrollToElement(htmlElement);
+                return;
+            }
+        }
+        console.warn(`❌ Could not find any suitable element to scroll to for field: ${fieldName}`);
+    }
+    /**
+     * Scroll to element with smooth animation
+     */
+    scrollToElement(element) {
+        try {
+            // Find the closest form field container
+            const formFieldContainer = element.closest('mat-form-field, formly-field, .form-field, .mat-mdc-form-field, .form-group');
+            const targetElement = formFieldContainer || element;
+            // Calculate offset to show element with some margin from top
+            const offset = 100; // pixels from top (increased for better visibility)
+            const elementPosition = targetElement.getBoundingClientRect().top + window.pageYOffset;
+            const offsetPosition = Math.max(0, elementPosition - offset);
+            // Use multiple scroll methods for better compatibility
+            this.performScroll(offsetPosition, element); // Pass the original element for focusing
+        }
+        catch (error) {
+            console.error('Error scrolling to element:', error);
+        }
+    }
+    /**
+     * Perform the actual scroll with multiple methods
+     */
+    performScroll(targetPosition, elementToFocus) {
+        // Method 1: Modern smooth scroll
+        try {
+            window.scrollTo({
+                top: targetPosition,
+                behavior: 'smooth'
+            });
+        }
+        catch (error) {
+            // Fallback for older browsers
+            window.scrollTo(0, targetPosition);
+        }
+        // Method 2: ScrollIntoView as backup
+        setTimeout(() => {
+            try {
+                elementToFocus.scrollIntoView({
+                    behavior: 'smooth',
+                    block: 'center',
+                    inline: 'nearest'
+                });
+            }
+            catch (error) {
+                // Fallback for older browsers
+                elementToFocus.scrollIntoView();
+            }
+        }, 100);
+        // Method 3: Focus with delay to ensure scroll completion
+        setTimeout(() => {
+            this.focusElement(elementToFocus);
+        }, 600); // Wait for scroll animation to complete
+    }
+    /**
+     * Focus on the target element
+     */
+    focusElement(targetElement) {
+        try {
+            // If the target element is directly focusable and invalid, focus it
+            if (targetElement.classList.contains('ng-invalid') &&
+                (targetElement instanceof HTMLInputElement ||
+                    targetElement instanceof HTMLSelectElement ||
+                    targetElement instanceof HTMLTextAreaElement)) {
+                targetElement.focus();
+                // For input elements, also select the text
+                if (targetElement instanceof HTMLInputElement && targetElement.type === 'text') {
+                    targetElement.select();
+                }
+                return;
+            }
+            // Look for invalid focusable elements within the target
+            const invalidFocusableSelectors = [
+                'input.ng-invalid:not([disabled]):not([readonly])',
+                'select.ng-invalid:not([disabled])',
+                'textarea.ng-invalid:not([disabled]):not([readonly])',
+                'mat-radio-group.ng-invalid',
+                'mat-checkbox.ng-invalid'
+            ];
+            for (const selector of invalidFocusableSelectors) {
+                const focusableElement = targetElement.querySelector(selector);
+                if (focusableElement && this.isElementVisible(focusableElement)) {
+                    focusableElement.focus();
+                    // For input elements, also select the text
+                    if (focusableElement instanceof HTMLInputElement && focusableElement.type === 'text') {
+                        focusableElement.select();
+                    }
+                    return;
+                }
+            }
+            // If no invalid elements found, look for any focusable elements
+            const focusableSelectors = [
+                'input:not([disabled]):not([readonly])',
+                'select:not([disabled])',
+                'textarea:not([disabled]):not([readonly])',
+                'button:not([disabled])',
+                'mat-radio-group',
+                'mat-checkbox',
+                '[tabindex="0"]'
+            ];
+            for (const selector of focusableSelectors) {
+                const focusableElement = targetElement.querySelector(selector);
+                if (focusableElement && this.isElementVisible(focusableElement)) {
+                    focusableElement.focus();
+                    // For input elements, also select the text
+                    if (focusableElement instanceof HTMLInputElement && focusableElement.type === 'text') {
+                        focusableElement.select();
+                    }
+                    return;
+                }
+            }
+            // If no focusable element found, try to focus the target itself
+            if (targetElement.tabIndex >= 0) {
+                targetElement.focus();
+            }
+        }
+        catch (error) {
+            console.error('Error focusing element:', error);
+        }
+    }
+    /**
+     * Debug log all form elements for troubleshooting
+     */
+    debugLogFormElements() {
+        console.group('🐛 Form Elements Debug');
+        const formElements = document.querySelectorAll('input, select, textarea, formly-field');
+        formElements.forEach((element, index) => {
+            const htmlElement = element;
+        });
+        const invalidElements = document.querySelectorAll('.ng-invalid');
+        console.groupEnd();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollToErrorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-to-error.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/scroll-to-error.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AbstractControl, FormGroup } from '@angular/forms';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ScrollToErrorService {\n\n  /**\n   * Scroll to the first validation error in a form\n   */\n  scrollToFirstError(form: FormGroup): void {\n    try {\n      // Find the first invalid control\n      const firstInvalidControl = this.findFirstInvalidControl(form);\n      if (firstInvalidControl) {\n        this.scrollToField(firstInvalidControl.name);\n      }\n    } catch (error) {\n      console.error('Error scrolling to first error:', error);\n    }\n  }\n\n  /**\n   * Scroll to a specific field by name\n   */\n  scrollToField(fieldName: string): void {\n    // Add a small delay to ensure DOM is ready\n    setTimeout(() => {\n      const element = this.findFormFieldElement(fieldName);\n      if (element) {\n        this.scrollToElement(element);\n      } else {\n        this.tryFindMatchingInvalidField(fieldName);\n      }\n    }, 100);\n  }\n\n  /**\n   * Find first invalid control in form\n   */\n  private findFirstInvalidControl(formGroup: FormGroup, parentName = ''): { name: string; control: AbstractControl } | null {\n    for (const controlName in formGroup.controls) {\n      const control = formGroup.controls[controlName];\n      const fullControlName = parentName ? `${parentName}.${controlName}` : controlName;\n\n      if (control instanceof FormGroup) {\n        const nestedInvalid = this.findFirstInvalidControl(control, fullControlName);\n        if (nestedInvalid) {\n          return nestedInvalid;\n        }\n      } else {\n        // Check if this control is invalid\n        if (control.invalid && (control.dirty || control.touched)) {\n          return { name: fullControlName, control };\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Find form field element by various selectors\n   */\n  private findFormFieldElement(fieldName: string): HTMLElement | null {\n    if (!fieldName) return null;\n    \n    // Clean the field name for better matching\n    const cleanFieldName = fieldName.replace(/[.\\[\\]]/g, '');\n    \n    // Try various selectors to find the form field\n    const selectors = [\n      // Formly specific selectors\n      `formly-field[ng-reflect-field*=\"${fieldName}\"]`,\n      `formly-field[ng-reflect-field*=\"${cleanFieldName}\"]`,\n      `[data-cy=\"${fieldName}\"]`,\n      `[data-cy=\"${cleanFieldName}\"]`,\n      \n      // Form control selectors\n      `input[formcontrolname=\"${fieldName}\"]`,\n      `select[formcontrolname=\"${fieldName}\"]`,\n      `textarea[formcontrolname=\"${fieldName}\"]`,\n      `input[formcontrolname=\"${cleanFieldName}\"]`,\n      `select[formcontrolname=\"${cleanFieldName}\"]`,\n      `textarea[formcontrolname=\"${cleanFieldName}\"]`,\n      \n      // Name and ID selectors\n      `input[name=\"${fieldName}\"]`,\n      `select[name=\"${fieldName}\"]`,\n      `textarea[name=\"${fieldName}\"]`,\n      `#${fieldName}`,\n      `#${cleanFieldName}`,\n      \n      // Class selectors\n      `.field-${fieldName}`,\n      `.field-${cleanFieldName}`,\n      \n      // Angular Material specific\n      `mat-form-field:has(input[formcontrolname=\"${fieldName}\"])`,\n      `mat-form-field:has(select[formcontrolname=\"${fieldName}\"])`,\n      `mat-form-field:has(textarea[formcontrolname=\"${fieldName}\"])`,\n      \n      // Generic error class selectors\n      `.ng-invalid[formcontrolname=\"${fieldName}\"]`,\n      `.ng-invalid[name=\"${fieldName}\"]`,\n      \n      // Broader searches\n      `[ng-reflect-name=\"${fieldName}\"]`,\n      `[ng-reflect-key=\"${fieldName}\"]`\n    ];\n    \n    for (const selector of selectors) {\n      try {\n        const element = document.querySelector(selector) as HTMLElement;\n        if (element && this.isElementVisible(element)) {\n          return element;\n        }\n      } catch (error) {\n        // Some selectors might be invalid, continue trying others\n        continue;\n      }\n    }\n    \n    // Fallback: search through all elements\n    return this.fallbackElementSearch(fieldName, cleanFieldName);\n  }\n\n  /**\n   * Fallback search through all elements\n   */\n  private fallbackElementSearch(fieldName: string, cleanFieldName: string): HTMLElement | null {\n    const allElements = document.querySelectorAll('input, select, textarea, formly-field, mat-form-field');\n    \n    for (const element of Array.from(allElements)) {\n      const htmlElement = element as HTMLElement;\n      \n      // Check various attributes\n      const attributes = [\n        'formcontrolname',\n        'name',\n        'id',\n        'ng-reflect-name',\n        'ng-reflect-key',\n        'data-cy'\n      ];\n      \n      for (const attr of attributes) {\n        const attrValue = htmlElement.getAttribute(attr);\n        if (attrValue === fieldName || attrValue === cleanFieldName) {\n          if (this.isElementVisible(htmlElement)) {\n            return htmlElement;\n          }\n        }\n      }\n      \n      // Check class names\n      if (htmlElement.classList.contains(`field-${fieldName}`) || \n          htmlElement.classList.contains(`field-${cleanFieldName}`)) {\n        if (this.isElementVisible(htmlElement)) {\n          return htmlElement;\n        }\n      }\n    }\n    \n    return null;\n  }\n\n  /**\n   * Check if element is visible\n   */\n  private isElementVisible(element: HTMLElement): boolean {\n    const rect = element.getBoundingClientRect();\n    const style = window.getComputedStyle(element);\n    \n    return rect.width > 0 && \n           rect.height > 0 && \n           style.visibility !== 'hidden' && \n           style.display !== 'none' &&\n           style.opacity !== '0';\n  }\n\n  /**\n   * Try to find a matching invalid field when direct search fails\n   */\n  private tryFindMatchingInvalidField(fieldName: string): void {\n    \n    const cleanFieldName = fieldName.replace(/[.\\[\\]]/g, '');\n    \n    // Get all invalid elements\n    const invalidElements = document.querySelectorAll('.ng-invalid');\n    \n    // Try to find one that matches our field name\n    for (const element of Array.from(invalidElements)) {\n      const htmlElement = element as HTMLElement;\n      \n      // Check if this invalid element matches our field\n      const attributes = ['formcontrolname', 'name', 'id', 'ng-reflect-name', 'ng-reflect-key'];\n      for (const attr of attributes) {\n        const attrValue = htmlElement.getAttribute(attr);\n        if (attrValue === fieldName || attrValue === cleanFieldName) {\n          if (this.isElementVisible(htmlElement)) {\n            this.scrollToElement(htmlElement);\n            return;\n          }\n        }\n      }\n      \n      // Check for partial matches in IDs (formly generates IDs with field names)\n      const id = htmlElement.getAttribute('id');\n      if (id && (id.includes(fieldName) || id.includes(cleanFieldName))) {\n        if (this.isElementVisible(htmlElement)) {\n          this.scrollToElement(htmlElement);\n          return;\n        }\n      }\n    }\n    \n    // If no matching invalid element found, try formly field containers\n    this.tryFindFormlyFieldContainer(fieldName, cleanFieldName);\n  }\n\n  /**\n   * Try to find formly field container and look for invalid elements within it\n   */\n  private tryFindFormlyFieldContainer(fieldName: string, cleanFieldName: string): void {    \n    const formlyFields = document.querySelectorAll('formly-field');\n    \n    for (const formlyField of Array.from(formlyFields)) {\n      const fieldElement = formlyField as HTMLElement;\n      \n      // Check if this formly field's ng-reflect-field contains our field name\n      const ngReflectField = fieldElement.getAttribute('ng-reflect-field');\n      if (ngReflectField && \n          (ngReflectField.includes(`\"key\":\"${fieldName}\"`) || \n           ngReflectField.includes(`\"key\":\"${cleanFieldName}\"`))) {\n        \n        \n        // Look for invalid elements within this container\n        const invalidInContainer = fieldElement.querySelector('.ng-invalid');\n        if (invalidInContainer && this.isElementVisible(invalidInContainer as HTMLElement)) {\n          this.scrollToElement(invalidInContainer as HTMLElement);\n          return;\n        }\n        \n        // If no invalid element, scroll to the container itself\n        if (this.isElementVisible(fieldElement)) {\n          this.scrollToElement(fieldElement);\n          return;\n        }\n      }\n    }\n    \n    // Last resort: scroll to first visible invalid element\n    const invalidElements = document.querySelectorAll('.ng-invalid');\n    for (const element of Array.from(invalidElements)) {\n      const htmlElement = element as HTMLElement;\n      if (this.isElementVisible(htmlElement)) {\n        this.scrollToElement(htmlElement);\n        return;\n      }\n    }\n    \n    console.warn(`❌ Could not find any suitable element to scroll to for field: ${fieldName}`);\n  }\n\n  /**\n   * Scroll to element with smooth animation\n   */\n  private scrollToElement(element: HTMLElement): void {\n    try {\n      // Find the closest form field container\n      const formFieldContainer = element.closest('mat-form-field, formly-field, .form-field, .mat-mdc-form-field, .form-group') as HTMLElement;\n      const targetElement = formFieldContainer || element;\n      \n      // Calculate offset to show element with some margin from top\n      const offset = 100; // pixels from top (increased for better visibility)\n      const elementPosition = targetElement.getBoundingClientRect().top + window.pageYOffset;\n      const offsetPosition = Math.max(0, elementPosition - offset);\n      \n      // Use multiple scroll methods for better compatibility\n      this.performScroll(offsetPosition, element); // Pass the original element for focusing\n      \n    } catch (error) {\n      console.error('Error scrolling to element:', error);\n    }\n  }\n\n  /**\n   * Perform the actual scroll with multiple methods\n   */\n  private performScroll(targetPosition: number, elementToFocus: HTMLElement): void {\n    // Method 1: Modern smooth scroll\n    try {\n      window.scrollTo({\n        top: targetPosition,\n        behavior: 'smooth'\n      });\n    } catch (error) {\n      // Fallback for older browsers\n      window.scrollTo(0, targetPosition);\n    }\n    \n    // Method 2: ScrollIntoView as backup\n    setTimeout(() => {\n      try {\n        elementToFocus.scrollIntoView({\n          behavior: 'smooth',\n          block: 'center',\n          inline: 'nearest'\n        });\n      } catch (error) {\n        // Fallback for older browsers\n        elementToFocus.scrollIntoView();\n      }\n    }, 100);\n    \n    // Method 3: Focus with delay to ensure scroll completion\n    setTimeout(() => {\n      this.focusElement(elementToFocus);\n    }, 600); // Wait for scroll animation to complete\n  }\n\n  /**\n   * Focus on the target element\n   */\n  private focusElement(targetElement: HTMLElement): void {\n    try {\n      \n      // If the target element is directly focusable and invalid, focus it\n      if (targetElement.classList.contains('ng-invalid') && \n          (targetElement instanceof HTMLInputElement || \n           targetElement instanceof HTMLSelectElement || \n           targetElement instanceof HTMLTextAreaElement)) {\n        targetElement.focus();\n        \n        // For input elements, also select the text\n        if (targetElement instanceof HTMLInputElement && targetElement.type === 'text') {\n          targetElement.select();\n        }\n        return;\n      }\n      \n      // Look for invalid focusable elements within the target\n      const invalidFocusableSelectors = [\n        'input.ng-invalid:not([disabled]):not([readonly])',\n        'select.ng-invalid:not([disabled])',\n        'textarea.ng-invalid:not([disabled]):not([readonly])',\n        'mat-radio-group.ng-invalid',\n        'mat-checkbox.ng-invalid'\n      ];\n      \n      for (const selector of invalidFocusableSelectors) {\n        const focusableElement = targetElement.querySelector(selector) as HTMLElement;\n        if (focusableElement && this.isElementVisible(focusableElement)) {\n          focusableElement.focus();\n          \n          // For input elements, also select the text\n          if (focusableElement instanceof HTMLInputElement && focusableElement.type === 'text') {\n            focusableElement.select();\n          }\n          return;\n        }\n      }\n      \n      // If no invalid elements found, look for any focusable elements\n      const focusableSelectors = [\n        'input:not([disabled]):not([readonly])',\n        'select:not([disabled])',\n        'textarea:not([disabled]):not([readonly])',\n        'button:not([disabled])',\n        'mat-radio-group',\n        'mat-checkbox',\n        '[tabindex=\"0\"]'\n      ];\n      \n      for (const selector of focusableSelectors) {\n        const focusableElement = targetElement.querySelector(selector) as HTMLElement;\n        if (focusableElement && this.isElementVisible(focusableElement)) {\n          focusableElement.focus();\n          \n          // For input elements, also select the text\n          if (focusableElement instanceof HTMLInputElement && focusableElement.type === 'text') {\n            focusableElement.select();\n          }\n          return;\n        }\n      }\n      \n      // If no focusable element found, try to focus the target itself\n      if (targetElement.tabIndex >= 0) {\n        targetElement.focus();\n      }\n    } catch (error) {\n      console.error('Error focusing element:', error);\n    }\n  }\n\n  /**\n   * Debug log all form elements for troubleshooting\n   */\n  debugLogFormElements(): void {\n    console.group('🐛 Form Elements Debug');\n    \n    const formElements = document.querySelectorAll('input, select, textarea, formly-field');\n    \n    formElements.forEach((element, index) => {\n      const htmlElement = element as HTMLElement;\n    });\n    \n    const invalidElements = document.querySelectorAll('.ng-invalid');\n    \n    console.groupEnd();\n  }\n} "]}

package/esm2022/lib/services/translation.service.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from "@angular/core";
+import { Utils } from "../others/utils";
+import * as i0 from "@angular/core";
+export class TranslationService {
+    constructor() {
+        this.dictionary = {};
+    }
+    setLabels(labels) {
+        labels?.forEach((label) => {
+            this.dictionary[label.labelName] = label.labelValue;
+        });
+    }
+    translate(key, args) {
+        var translated = this.dictionary[key] ?? key;
+        if (args?.length > 0) {
+            translated = Utils.formatString(translated, args);
+        }
+        return translated;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared-components/confirmation.component.mjs

@@ -0,0 +1,34 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { LabelKeys } from '../enums/label.keys';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/card";
+import * as i3 from "@angular/material/button";
+import * as i4 from "../others/translation.pipe";
+export class ConfirmationComponent {
+    constructor(data, dialog) {
+        this.data = data;
+        this.dialog = dialog;
+        this.commonKeys = LabelKeys.common;
+        this.item = data.item;
+        this.text = data.text;
+    }
+    ngOnInit() { }
+    submit() {
+        this.dialog.close({ event: 'submit', item: this.item });
+    }
+    cancel() {
+        this.dialog.close({ event: 'cancel' });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConfirmationComponent, deps: [{ token: MAT_DIALOG_DATA }, { token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ConfirmationComponent, selector: "app-confirmation", ngImport: i0, template: "<mat-card class=\"cardWithShadow blue_theme theme-card m-b-0\">\n  <mat-card-header>\n    <mat-card-title class=\"m-b-0\">\n      {{ commonKeys.confirmation.title | translate }}\n    </mat-card-title>\n  </mat-card-header>\n  <mat-card-content class=\"b-t-1\">\n    {{ text | translate }}\n    <div class=\"m-t-24\">\n      <button mat-flat-button type=\"button\" (click)=\"submit()\" color=\"primary\" class=\"m-r-16\">\n        {{ commonKeys.actions.confirm | translate }}\n      </button>\n      <button mat-flat-button type=\"button\" (click)=\"cancel()\">\n        {{ commonKeys.actions.cancel | translate }}\n      </button>\n    </div>\n  </mat-card-content>\n</mat-card>\n", styles: [""], dependencies: [{ kind: "component", type: i2.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i2.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i2.MatCardHeader, selector: "mat-card-header" }, { kind: "directive", type: i2.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { kind: "component", type: i3.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConfirmationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-confirmation', template: "<mat-card class=\"cardWithShadow blue_theme theme-card m-b-0\">\n  <mat-card-header>\n    <mat-card-title class=\"m-b-0\">\n      {{ commonKeys.confirmation.title | translate }}\n    </mat-card-title>\n  </mat-card-header>\n  <mat-card-content class=\"b-t-1\">\n    {{ text | translate }}\n    <div class=\"m-t-24\">\n      <button mat-flat-button type=\"button\" (click)=\"submit()\" color=\"primary\" class=\"m-r-16\">\n        {{ commonKeys.actions.confirm | translate }}\n      </button>\n      <button mat-flat-button type=\"button\" (click)=\"cancel()\">\n        {{ commonKeys.actions.cancel | translate }}\n      </button>\n    </div>\n  </mat-card-content>\n</mat-card>\n" }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i1.MatDialogRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlybWF0aW9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29yaWdpbi1mb3JtL3NyYy9saWIvc2hhcmVkLWNvbXBvbmVudHMvY29uZmlybWF0aW9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29yaWdpbi1mb3JtL3NyYy9saWIvc2hhcmVkLWNvbXBvbmVudHMvY29uZmlybWF0aW9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFVLE1BQU0sZUFBZSxDQUFDO0FBQzFELE9BQU8sRUFBRSxlQUFlLEVBQWdCLE1BQU0sMEJBQTBCLENBQUM7QUFDekUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDOzs7Ozs7QUFPaEQsTUFBTSxPQUFPLHFCQUFxQjtJQU1oQyxZQUNtQyxJQUFpQyxFQUMzRCxNQUEyQztRQURqQixTQUFJLEdBQUosSUFBSSxDQUE2QjtRQUMzRCxXQUFNLEdBQU4sTUFBTSxDQUFxQztRQVA3QyxlQUFVLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQztRQVNuQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUM7UUFDdEIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxRQUFRLEtBQVUsQ0FBQztJQUVuQixNQUFNO1FBQ0osSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRUQsTUFBTTtRQUNKLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDekMsQ0FBQzsrR0F0QlUscUJBQXFCLGtCQU90QixlQUFlO21HQVBkLHFCQUFxQix3RENUbEMsMHFCQWtCQTs7NEZEVGEscUJBQXFCO2tCQUxqQyxTQUFTOytCQUNFLGtCQUFrQjs7MEJBV3pCLE1BQU07MkJBQUMsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5qZWN0LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1BVF9ESUFMT0dfREFUQSwgTWF0RGlhbG9nUmVmIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcbmltcG9ydCB7IExhYmVsS2V5cyB9IGZyb20gJy4uL2VudW1zL2xhYmVsLmtleXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhcHAtY29uZmlybWF0aW9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2NvbmZpcm1hdGlvbi5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2NvbmZpcm1hdGlvbi5jb21wb25lbnQuc2NzcyddLFxufSlcbmV4cG9ydCBjbGFzcyBDb25maXJtYXRpb25Db21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBwdWJsaWMgY29tbW9uS2V5cyA9IExhYmVsS2V5cy5jb21tb247XG5cbiAgaXRlbTogYW55O1xuICB0ZXh0OiBhbnk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgQEluamVjdChNQVRfRElBTE9HX0RBVEEpIHByaXZhdGUgZGF0YTogeyBpdGVtOiBhbnk7IHRleHQ6IHN0cmluZyB9LFxuICAgIHB1YmxpYyBkaWFsb2c6IE1hdERpYWxvZ1JlZjxDb25maXJtYXRpb25Db21wb25lbnQ+XG4gICkge1xuICAgIHRoaXMuaXRlbSA9IGRhdGEuaXRlbTtcbiAgICB0aGlzLnRleHQgPSBkYXRhLnRleHQ7XG4gIH1cblxuICBuZ09uSW5pdCgpOiB2b2lkIHt9XG5cbiAgc3VibWl0KCk6IHZvaWQge1xuICAgIHRoaXMuZGlhbG9nLmNsb3NlKHsgZXZlbnQ6ICdzdWJtaXQnLCBpdGVtOiB0aGlzLml0ZW0gfSk7XG4gIH1cblxuICBjYW5jZWwoKTogdm9pZCB7XG4gICAgdGhpcy5kaWFsb2cuY2xvc2UoeyBldmVudDogJ2NhbmNlbCcgfSk7XG4gIH1cbn1cbiIsIjxtYXQtY2FyZCBjbGFzcz1cImNhcmRXaXRoU2hhZG93IGJsdWVfdGhlbWUgdGhlbWUtY2FyZCBtLWItMFwiPlxuICA8bWF0LWNhcmQtaGVhZGVyPlxuICAgIDxtYXQtY2FyZC10aXRsZSBjbGFzcz1cIm0tYi0wXCI+XG4gICAgICB7eyBjb21tb25LZXlzLmNvbmZpcm1hdGlvbi50aXRsZSB8IHRyYW5zbGF0ZSB9fVxuICAgIDwvbWF0LWNhcmQtdGl0bGU+XG4gIDwvbWF0LWNhcmQtaGVhZGVyPlxuICA8bWF0LWNhcmQtY29udGVudCBjbGFzcz1cImItdC0xXCI+XG4gICAge3sgdGV4dCB8IHRyYW5zbGF0ZSB9fVxuICAgIDxkaXYgY2xhc3M9XCJtLXQtMjRcIj5cbiAgICAgIDxidXR0b24gbWF0LWZsYXQtYnV0dG9uIHR5cGU9XCJidXR0b25cIiAoY2xpY2spPVwic3VibWl0KClcIiBjb2xvcj1cInByaW1hcnlcIiBjbGFzcz1cIm0tci0xNlwiPlxuICAgICAgICB7eyBjb21tb25LZXlzLmFjdGlvbnMuY29uZmlybSB8IHRyYW5zbGF0ZSB9fVxuICAgICAgPC9idXR0b24+XG4gICAgICA8YnV0dG9uIG1hdC1mbGF0LWJ1dHRvbiB0eXBlPVwiYnV0dG9uXCIgKGNsaWNrKT1cImNhbmNlbCgpXCI+XG4gICAgICAgIHt7IGNvbW1vbktleXMuYWN0aW9ucy5jYW5jZWwgfCB0cmFuc2xhdGUgfX1cbiAgICAgIDwvYnV0dG9uPlxuICAgIDwvZGl2PlxuICA8L21hdC1jYXJkLWNvbnRlbnQ+XG48L21hdC1jYXJkPlxuIl19