@fovestta2/web-angular 1.0.1 → 1.0.3

package/esm2022/lib/add-update-form/add-update-form.component.mjs

@@ -0,0 +1,1044 @@
+// add-update-form.component.ts
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule, Validators, } from '@angular/forms';
+import { distinctUntilChanged } from 'rxjs/operators';
+// Import your library modules
+import { FvEntryFieldComponent } from '../fv-entry-field/fv-entry-field.component';
+import { FvNumberFieldComponent } from '../fv-number-field/fv-number-field.component';
+import { FvDropdownComponent } from '../fv-dropdown/fv-dropdown.component';
+import { FvRadioGroupComponent } from '../fv-radio-group/fv-radio-group.component';
+import { FvCheckboxComponent } from '../fv-checkbox/fv-checkbox.component';
+import { FvDateFieldComponent } from '../fv-date-field/fv-date-field.component';
+import { FvMonthYearFieldComponent } from '../fv-month-year-field/fv-month-year-field.component';
+import { FvFileSelectorComponent } from '../fv-file-selector/fv-file-selector.component';
+import { FvImageSelectorComponent } from '../fv-image-selector/fv-image-selector.component';
+import { FvRichTextEditorComponent } from '../fv-rich-text-editor/fv-rich-text-editor.component';
+import { FvNameCodeComponent } from '../fv-name-code/fv-name-code.component';
+import { FvPhoneFieldComponent } from '../fv-phone-field/fv-phone-field.component';
+import { FvUanFieldComponent } from '../fv-uan-field/fv-uan-field.component';
+import { FvPfFieldComponent } from '../fv-pf-field/fv-pf-field.component';
+import { FvEsiFieldComponent } from '../fv-esi-field/fv-esi-field.component';
+import { FvIfscFieldComponent } from '../fv-ifsc-field/fv-ifsc-field.component';
+import { FvMicrFieldComponent } from '../fv-micr-field/fv-micr-field.component';
+import { FvIbanFieldComponent } from '../fv-iban-field/fv-iban-field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/common";
+export class AddUpdateFormComponent {
+    fb;
+    hostRef;
+    config;
+    validationError = new EventEmitter();
+    form;
+    submitted = false;
+    filePreviews = new Map();
+    fileNames = new Map();
+    valueChangeSubscriptions = [];
+    passwordVisibility = new Map();
+    searchQueries = new Map();
+    constructor(fb, hostRef) {
+        this.fb = fb;
+        this.hostRef = hostRef;
+    }
+    ngOnInit() {
+        this.initializeForm();
+    }
+    ngAfterViewInit() {
+        // Lifecycle hook - can be used for datepicker initialization if needed
+    }
+    getColumnWidth(column) {
+        const maxCols = this.config.maxColsPerRow || 5;
+        const colSpan = Math.min(column.colSpan || 1, maxCols);
+        return `calc(${(colSpan / maxCols) * 100}% - 16px)`;
+    }
+    getControl(name) {
+        return this.form.get(name);
+    }
+    // 2. HELPER: Convert your FieldValidation[] to the library's ValidationSchema
+    getSchema(column) {
+        const rules = [];
+        const errorPriority = [];
+        if (column.validations) {
+            column.validations.forEach((v) => {
+                switch (v.type) {
+                    case 'required':
+                        rules.push({
+                            name: 'required',
+                            params: { enabled: true },
+                            errorKey: 'ERR_REQUIRED',
+                        });
+                        errorPriority.push('required');
+                        break;
+                    case 'email':
+                        rules.push({
+                            name: 'regex',
+                            params: {
+                                pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$',
+                            },
+                            errorKey: 'ERR_REGEX_MISMATCH',
+                        });
+                        errorPriority.push('regex');
+                        break;
+                    case 'minLength':
+                        rules.push({
+                            name: 'minLength',
+                            params: { value: v.value },
+                            errorKey: 'ERR_MIN_LENGTH',
+                        });
+                        errorPriority.push('minLength');
+                        break;
+                    case 'maxLength':
+                        rules.push({
+                            name: 'maxLength',
+                            params: { value: v.value },
+                            errorKey: 'ERR_MAX_LENGTH',
+                        });
+                        errorPriority.push('maxLength');
+                        break;
+                    case 'pattern':
+                        rules.push({
+                            name: 'regex',
+                            params: { pattern: v.value },
+                            errorKey: 'ERR_REGEX_MISMATCH',
+                        });
+                        errorPriority.push('regex');
+                        break;
+                    case 'min':
+                        rules.push({
+                            name: 'min',
+                            params: { value: v.value },
+                            errorKey: 'ERR_MIN_VALUE',
+                        });
+                        errorPriority.push('min');
+                        break;
+                    case 'max':
+                        rules.push({
+                            name: 'max',
+                            params: { value: v.value },
+                            errorKey: 'ERR_MAX_VALUE',
+                        });
+                        errorPriority.push('max');
+                        break;
+                }
+            });
+        }
+        // Map 'name-code' to 'Dropdown' or similar for validation schema purposes if needed
+        let controlType = column.type;
+        if (column.type === 'name-code') {
+            controlType = 'select'; // Treat as select for schema lookup if library expects 'select' or 'Dropdown'
+        }
+        return {
+            controlType: controlType,
+            errorPriority: errorPriority,
+            rules: rules,
+        };
+    }
+    isImageField(column) {
+        return (column.type === 'file' &&
+            (column.accept?.startsWith('image') || column.filePreview === true));
+    }
+    initializeForm() {
+        this.submitted = false;
+        const formGroupConfig = {};
+        this.config.sections.forEach((section) => {
+            section.fields.forEach((column) => {
+                let initialValue = column.value || '';
+                // Format month-year fields to YYYY-MM format
+                if (column.type === 'month-year' && initialValue) {
+                    initialValue = this.formatMonthYearValue(initialValue);
+                }
+                formGroupConfig[column.name] = [
+                    { value: initialValue, disabled: column.disabled || false },
+                    null, // We'll set validators after form creation
+                ];
+                // If it's a file field with an existing value, set the preview
+                if (column.type === 'file' && column.value) {
+                    this.filePreviews.set(column.name, column.value);
+                    // Extract filename from URL or base64
+                    const fileName = this.extractFileName(column.value);
+                    if (fileName) {
+                        this.fileNames.set(column.name, fileName);
+                    }
+                }
+                // Initialize search display for name-code fields - No longer needed as FvNameCode handles display internally
+                /* if (column.type === 'name-code' && initialValue && column.options) {
+                     // Logic moved to component
+                } */
+            });
+        });
+        this.form = this.fb.group(formGroupConfig);
+        this.config.sections.forEach((section) => {
+            section.fields.forEach((column) => {
+                const validators = this.buildValidators(column.validations, this.form);
+                if (validators.length > 0) {
+                    this.form.get(column.name)?.setValidators(validators);
+                    this.form.get(column.name)?.updateValueAndValidity();
+                }
+            });
+        });
+        // Subscribe to value changes for all fields to trigger onChange handlers
+        Object.keys(this.form.controls).forEach((key) => {
+            const control = this.form.get(key);
+            if (control) {
+                const subscription = control.valueChanges
+                    .pipe(distinctUntilChanged())
+                    .subscribe((value) => {
+                    const column = this.getColumnByName(key);
+                    if (column?.onChange) {
+                        column.onChange(value, this.form);
+                    }
+                });
+                this.valueChangeSubscriptions.push(subscription);
+            }
+        });
+    }
+    ngOnDestroy() {
+        // Clean up all subscriptions to prevent memory leaks
+        this.valueChangeSubscriptions.forEach((sub) => sub.unsubscribe());
+        this.valueChangeSubscriptions = [];
+    }
+    handleFieldChange(fieldName, eventValue) {
+        const column = this.getColumnByName(fieldName);
+        const formControl = this.form.get(fieldName);
+        // Format month-year fields (especially expiryDate) to YYYY-MM
+        if (column?.type === 'month-year' && eventValue) {
+            const formattedValue = this.formatMonthYearValue(eventValue);
+            if (formControl && formattedValue !== eventValue) {
+                formControl.setValue(formattedValue, { emitEvent: false });
+                eventValue = formattedValue;
+            }
+        }
+        if (column?.onChange) {
+            // Use the event value directly (what the user just selected/typed)
+            // This ensures we have the correct value even if form control hasn't updated yet
+            const valueToPass = eventValue !== undefined ? eventValue : this.form.get(fieldName)?.value;
+            const onChangeFn = column.onChange; // Store the function reference
+            // Store the selected value - this is what the user chose
+            const selectedValue = valueToPass;
+            // Ensure the form control has the selected value before calling onChange
+            if (formControl && selectedValue !== undefined) {
+                if (formControl.value !== selectedValue) {
+                    formControl.setValue(selectedValue, { emitEvent: false });
+                }
+            }
+            // Call onChange with the selected value
+            if (onChangeFn) {
+                onChangeFn(selectedValue, this.form);
+            }
+            // Restore the value for the field that triggered the change if it was cleared by onChange
+            // This is critical: if onChange clears the field that was just changed, we restore it
+            // Only restore if we had a non-empty value (empty string, null, undefined are not restored)
+            if (formControl &&
+                selectedValue !== undefined &&
+                selectedValue !== null &&
+                selectedValue !== '') {
+                // Use setTimeout with 0 delay to run after any synchronous operations in onChange
+                setTimeout(() => {
+                    // Check if the value was cleared or changed
+                    const currentValue = formControl.value;
+                    // If the value doesn't match what was selected, restore it
+                    // This handles the case where onChange cleared the field unintentionally
+                    if (currentValue !== selectedValue) {
+                        formControl.setValue(selectedValue, { emitEvent: false });
+                    }
+                }, 0);
+            }
+        }
+    }
+    formatMonthYearValue(value) {
+        if (!value)
+            return value;
+        // Normalize to YYYY-MM
+        if (value.match(/^\d{2}-\d{4}$/)) {
+            const [month, year] = value.split('-');
+            return `${year}-${month}`;
+        }
+        // If already in YYYY-MM format, return as is
+        return value;
+    }
+    parseMonthYearValue(value) {
+        if (!value)
+            return value;
+        // Display and picker both use YYYY-MM; normalize MM-YYYY if present
+        if (value.match(/^\d{2}-\d{4}$/)) {
+            const [month, year] = value.split('-');
+            return `${year}-${month}`;
+        }
+        return value;
+    }
+    handleMonthYearChange(fieldName, value) {
+        // Format the input value to YYYY-MM format
+        let formattedValue = value;
+        // If it's in MM-YYYY format, convert to YYYY-MM
+        if (formattedValue.match(/^\d{2}-\d{4}$/)) {
+            const [month, year] = formattedValue.split('-');
+            formattedValue = `${year}-${month}`;
+        }
+        // If it's in YYYYMM format (no dash), convert to YYYY-MM
+        else if (formattedValue.match(/^\d{6}$/)) {
+            const year = formattedValue.substring(0, 4);
+            const month = formattedValue.substring(4, 6);
+            formattedValue = `${year}-${month}`;
+        }
+        // If it's already in YYYY-MM format, leave as is
+        else if (formattedValue.match(/^\d{4}-\d{2}$/)) {
+            // Already in correct format
+        }
+        // If user is typing, allow partial input
+        else if (formattedValue.match(/^\d{1,6}$/)) {
+            // Allow partial input while typing
+        }
+        const formControl = this.form.get(fieldName);
+        if (formControl && formattedValue !== value) {
+            formControl.setValue(formattedValue, { emitEvent: false });
+        }
+        this.handleFieldChange(fieldName, formattedValue);
+    }
+    handleMonthYearBlur(fieldName) {
+        const formControl = this.form.get(fieldName);
+        if (!formControl)
+            return;
+        const value = formControl.value || '';
+        // Ensure the value is in YYYY-MM format on blur
+        if (value && !value.match(/^\d{4}-\d{2}$/)) {
+            // Try to parse and format
+            const formatted = this.formatMonthYearValue(value);
+            if (formatted !== value) {
+                formControl.setValue(formatted, { emitEvent: false });
+            }
+        }
+    }
+    handleMonthYearPickerChange(fieldName, value) {
+        // Month picker outputs YYYY-MM; just normalize
+        const formattedValue = this.formatMonthYearValue(value);
+        const formControl = this.form.get(fieldName);
+        if (formControl) {
+            formControl.setValue(formattedValue, { emitEvent: false });
+            this.handleFieldChange(fieldName, formattedValue);
+        }
+    }
+    getMonthYearPickerValue(fieldName) {
+        const formControl = this.form.get(fieldName);
+        if (!formControl)
+            return '';
+        const value = formControl.value || '';
+        // Display and picker both expect YYYY-MM
+        return this.parseMonthYearValue(value);
+    }
+    openMonthPicker(fieldName) {
+        const monthInput = document.getElementById(fieldName + '_picker');
+        if (monthInput && monthInput.type === 'month') {
+            // Update the picker value before opening
+            const currentValue = this.getMonthYearPickerValue(fieldName);
+            if (currentValue) {
+                monthInput.value = currentValue;
+            }
+            // Try modern showPicker API first, fallback to click
+            if (monthInput.showPicker) {
+                monthInput.showPicker();
+            }
+            else {
+                monthInput.focus();
+                monthInput.click();
+            }
+        }
+    }
+    getColumnByName(name) {
+        return this.config.sections
+            .flatMap((s) => s.fields)
+            .find((c) => c.name === name);
+    }
+    getFileFields(fields) {
+        return fields.filter((f) => f.type === 'file');
+    }
+    getNonFileFields(fields) {
+        return fields.filter((f) => f.type !== 'file');
+    }
+    togglePasswordVisibility(fieldName) {
+        const current = this.passwordVisibility.get(fieldName) || false;
+        this.passwordVisibility.set(fieldName, !current);
+    }
+    hasRequiredValidation(column) {
+        return column.validations?.some((v) => v.type === 'required') || false;
+    }
+    isPasswordVisible(fieldName) {
+        return this.passwordVisibility.get(fieldName) || false;
+    }
+    buildValidators(validations, formGroup) {
+        if (!validations)
+            return [];
+        const validators = [];
+        validations.forEach((validation) => {
+            switch (validation.type) {
+                case 'required':
+                    validators.push(Validators.required);
+                    break;
+                case 'email':
+                    validators.push(Validators.email);
+                    break;
+                case 'minLength':
+                    validators.push(Validators.minLength(validation.value));
+                    break;
+                case 'maxLength':
+                    validators.push(Validators.maxLength(validation.value));
+                    break;
+                case 'min':
+                    validators.push(Validators.min(validation.value));
+                    break;
+                case 'max':
+                    validators.push(Validators.max(validation.value));
+                    break;
+                case 'pattern':
+                    validators.push(Validators.pattern(validation.value));
+                    break;
+                case 'custom':
+                    if (validation.validator) {
+                        validators.push((control) => {
+                            const isValid = validation.validator(control.value, formGroup);
+                            return isValid ? null : { custom: true };
+                        });
+                    }
+                    break;
+            }
+        });
+        return validators;
+    }
+    triggerFileUpload(fieldName) {
+        document.getElementById('fileInput_' + fieldName)?.click();
+    }
+    openTimePicker(fieldName) {
+        const timeInput = document.getElementById(fieldName);
+        if (timeInput && timeInput.type === 'time') {
+            // Try modern showPicker API first, fallback to click
+            if (timeInput.showPicker) {
+                timeInput.showPicker();
+            }
+            else {
+                timeInput.focus();
+                timeInput.click();
+            }
+        }
+    }
+    onFileChange(event, fieldName) {
+        const file = event.target.files[0];
+        if (file) {
+            this.fileNames.set(fieldName, file.name);
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => {
+                const base64String = reader.result;
+                this.filePreviews.set(fieldName, base64String);
+                this.form.get(fieldName)?.setValue(base64String);
+                // Trigger onChange handler for file fields
+                const column = this.getColumnByName(fieldName);
+                if (column?.onChange) {
+                    column.onChange(base64String, this.form);
+                }
+            };
+        }
+    }
+    extractFileName(value) {
+        if (!value)
+            return '';
+        // If it's a URL, extract filename from URL
+        if (value.startsWith('http')) {
+            const parts = value.split('/');
+            return parts[parts.length - 1];
+        }
+        // If it's base64, return a generic name
+        if (value.startsWith(`data:image`)) {
+            return 'uploaded-image.jpg';
+        }
+        return 'existing-photo.jpg';
+    }
+    getFilePreview(fieldName) {
+        return this.filePreviews.get(fieldName) || null;
+    }
+    getFileName(fieldName) {
+        return this.fileNames.get(fieldName) || null;
+    }
+    mapSearchOptions(options) {
+        return options.map(opt => ({
+            code: opt.code || opt.value,
+            name: opt.name || opt.label || opt.value,
+            value: opt.value
+        }));
+    }
+    deleteFile(fieldName) {
+        this.filePreviews.delete(fieldName);
+        this.fileNames.delete(fieldName);
+        this.form.get(fieldName)?.setValue('');
+        // Trigger onChange handler when file is deleted
+        const column = this.getColumnByName(fieldName);
+        if (column?.onChange) {
+            column.onChange('', this.form);
+        }
+    }
+    handleSubmit() {
+        this.submitted = true;
+        if (this.form.invalid) {
+            // Mark all fields as touched to show red borders
+            Object.keys(this.form.controls).forEach((key) => {
+                this.form.get(key)?.markAsTouched();
+            });
+            // Count only required fields that are invalid
+            const allColumns = this.config.sections.flatMap((s) => s.fields);
+            const invalidRequiredCount = Object.keys(this.form.controls).filter((key) => {
+                const control = this.form.get(key);
+                if (!control?.invalid)
+                    return false;
+                // Check if this field has required validation
+                const column = allColumns.find((c) => c.name === key);
+                return (column?.validations?.some((v) => v.type === 'required') || false);
+            }).length;
+            // Only emit if there are required fields missing
+            if (invalidRequiredCount > 0) {
+                this.validationError.emit(`Please fill all required fields marked with *. ${invalidRequiredCount} field(s) need attention.`);
+            }
+            return;
+        }
+        const formData = this.form.getRawValue();
+        this.config.onSubmit(formData);
+    }
+    handleReset() {
+        this.submitted = false;
+        this.form.reset();
+        if (this.config.onReset) {
+            this.config.onReset();
+        }
+    }
+    isFieldInvalid(fieldName) {
+        const field = this.form.get(fieldName);
+        return !!(field && field.invalid && this.submitted);
+    }
+    getErrorMessage(fieldName) {
+        const field = this.form.get(fieldName);
+        if (!field?.errors)
+            return '';
+        // Check if there's a custom message from validations
+        const allColumns = this.config.sections.flatMap((s) => s.fields);
+        const column = allColumns.find((c) => c.name === fieldName);
+        // Check for custom validation error
+        if (field.errors['custom']) {
+            const customValidation = column?.validations?.find((v) => v.type === 'custom');
+            return customValidation?.message || 'Invalid field';
+        }
+        // Check if there's a custom message from validations
+        const errorKeys = Object.keys(field.errors);
+        for (const key of errorKeys) {
+            const validation = column?.validations?.find((v) => v.type === key);
+            if (validation?.message) {
+                return validation.message;
+            }
+        }
+        // Default error messages
+        if (field.errors['required']) {
+            return `${column?.label} is required`;
+        }
+        if (field.errors['email'])
+            return 'Invalid email format';
+        if (field.errors['minlength'])
+            return `Minimum length is ${field.errors['minlength'].requiredLength}`;
+        if (field.errors['maxlength'])
+            return `Maximum length is ${field.errors['maxlength'].requiredLength}`;
+        if (field.errors['min'])
+            return `Minimum value is ${field.errors['min'].min}`;
+        if (field.errors['max'])
+            return `Maximum value is ${field.errors['max'].max}`;
+        if (field.errors['pattern'])
+            return 'Invalid format';
+        return 'Invalid field';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AddUpdateFormComponent, deps: [{ token: i1.FormBuilder }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AddUpdateFormComponent, isStandalone: true, selector: "lib-add-update-form", inputs: { config: "config" }, outputs: { validationError: "validationError" }, ngImport: i0, template: `
+    <div class="form-container">
+      <div class="form-header" *ngIf="config.formTitle">
+        <h2>{{ config.formTitle }}</h2>
+      </div>
+
+      <form [formGroup]="form" (ngSubmit)="handleSubmit()" class="dynamic-form">
+        <div *ngFor="let section of config.sections" class="form-section">
+          <h3 class="section-title" *ngIf="section.title">
+            {{ section.title }}
+          </h3>
+
+          <div class="fields-row">
+            <ng-container *ngFor="let column of section.fields">
+              <div
+                class="form-field-wrapper"
+                [ngClass]="'field-' + column.type"
+                [ngStyle]="column.hidden ? { display: 'none' } : {}"
+                [style.grid-column]="'span ' + (column.colSpan || 1)"
+              >
+                <ng-container
+                  *ngIf="
+                    ['text', 'email', 'password'].includes(column.type) &&
+                    !column.hidden
+                  "
+                >
+                  <fv-entry-field
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [type]="
+                      column.type === 'password'
+                        ? 'password'
+                        : column.type === 'email'
+                        ? 'email'
+                        : 'text'
+                    "
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    [readonly]="false"
+                    [allowAlphabetsOnly]="column.allowAlphabetsOnly || false"
+                    [maxLength]="column.maxLength || null"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-entry-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'number' && !column.hidden"
+                >
+                  <fv-number-field
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-number-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'select' && !column.hidden"
+                >
+                  <fv-dropdown
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || 'Select option'"
+                    [options]="column.options || []"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-dropdown>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'checkbox' && !column.hidden"
+                >
+                  <fv-checkbox
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-checkbox>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'radio' && !column.hidden">
+                  <fv-radio-group
+                    [label]="column.label"
+                    [options]="column.options || []"
+                    [control]="getControl(column.name)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-radio-group>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'date' && !column.hidden">
+                  <fv-date-field
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-date-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'month-year' && !column.hidden"
+                >
+                  <fv-month-year-field
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleMonthYearChange(column.name, $event)"
+                  >
+                  </fv-month-year-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'textarea' && !column.hidden"
+                >
+                  <fv-rich-text-editor
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-rich-text-editor>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'file' && !column.hidden">
+                  <ng-container *ngIf="isImageField(column); else standardFile">
+                    <fv-image-selector
+                      [label]="column.label"
+                      [placeholder]="column.placeholder || 'Select image'"
+                      [control]="getControl(column.name)"
+                      [schema]="getSchema(column)"
+                      [disabled]="column.disabled || false"
+                      (valueChange)="onFileChange($event, column.name)"
+                    >
+                    </fv-image-selector>
+                  </ng-container>
+
+                  <ng-template #standardFile>
+                    <fv-file-selector
+                      [label]="column.label"
+                      [placeholder]="column.placeholder || 'Select file'"
+                      [accept]="column.accept || '*/*'"
+                      [control]="getControl(column.name)"
+                      [schema]="getSchema(column)"
+                      [disabled]="column.disabled || false"
+                      (valueChange)="onFileChange($event, column.name)"
+                    >
+                    </fv-file-selector>
+                  </ng-template>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'name-code' && !column.hidden"
+                >
+                  <fv-name-code
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || 'Search by Code or Name'"
+                    [options]="column.options ? mapSearchOptions(column.options) : []"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                  >
+                  </fv-name-code>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'phone' && !column.hidden">
+                  <fv-phone-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-phone-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'uan' && !column.hidden">
+                  <fv-uan-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-uan-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'pf' && !column.hidden">
+                  <fv-pf-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-pf-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'esi' && !column.hidden">
+                  <fv-esi-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-esi-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'ifsc' && !column.hidden">
+                  <fv-ifsc-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-ifsc-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'micr' && !column.hidden">
+                  <fv-micr-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-micr-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'iban' && !column.hidden">
+                  <fv-iban-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-iban-field>
+                </ng-container>
+              </div>
+            </ng-container>
+          </div>
+        </div>
+
+
+        <div class="form-actions">
+          <button
+            type="submit"
+            class="btn btn-primary"
+            [disabled]="form.invalid && submitted"
+          >
+            {{ config.submitLabel || 'Save' }}
+          </button>
+          <button
+            type="button"
+            class="btn btn-outline"
+            (click)="config.onCancel()"
+          >
+            {{ config.cancelLabel || 'Cancel' }}
+          </button>
+        </div>
+      </form>
+    </div>
+  `, isInline: true, styles: ["@import\"https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap\";@import\"https://fonts.googleapis.com/icon?family=Material+Icons\";*{font-family:Poppins!important}.form-container{background:#f5f5f5;padding:10px;border-radius:8px;margin:0 auto;max-width:100%;overflow-x:hidden;box-sizing:border-box}.error-border{border-color:red!important}.hidden{display:none!important}.form-header{margin-bottom:10px}.form-header h2{margin:0;font-size:20px;font-weight:700;color:#303030}.dynamic-form{background:#fff;padding:10px;border-radius:6px;box-shadow:0 1px 3px #0000001a;max-width:100%;box-sizing:border-box}.form-section{margin-bottom:10px}.section-title{font-size:16px;font-weight:700;color:#303030;margin:0 0 16px;text-transform:uppercase;letter-spacing:.5px}.fields-row{display:grid;grid-template-columns:repeat(5,1fr);gap:16px;width:100%;box-sizing:border-box}.form-field-wrapper{display:flex;position:relative;flex-direction:column;min-width:0;width:100%;box-sizing:border-box}.password-toggle-btn{position:absolute;right:10px;top:32px;background:none;border:none;cursor:pointer;padding:4px;color:#666}.password-toggle-btn:hover{color:#333}.password-toggle-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}@media (min-width: 1200px) and (max-width: 1400px){.fields-row{grid-template-columns:repeat(5,1fr)}.form-control{width:180px;max-width:180px}}@media (max-width: 1200px){.fields-row{grid-template-columns:repeat(3,1fr)}.form-control{width:100%;max-width:100%}}@media (max-width: 992px){.fields-row{grid-template-columns:repeat(2,1fr);gap:12px}}@media (max-width: 768px){.fields-row{grid-template-columns:repeat(2,1fr);gap:10px}}@media (max-width: 640px){.fields-row{grid-template-columns:1fr;gap:12px}.form-field-wrapper{width:100%}}label{font-weight:600;margin-bottom:6px;color:#151d48;font-size:14px}.required{color:#e74c3c;margin-left:2px}.form-control{padding:5px 10px;width:100%;max-width:100%;border:1px solid #8CBBA8;border-radius:8px;background-color:#fff;font-size:14px;font-weight:400;font-family:inherit;color:#1f2b41;transition:border-color .2s,box-shadow .2s;box-sizing:border-box}.form-control:focus{outline:none;border-color:#3498db;box-shadow:0 0 0 3px #3498db1a}.form-control:disabled{background-color:#ecf0f1;cursor:not-allowed}textarea.form-control{resize:vertical;min-height:100px}select.form-control{cursor:pointer;appearance:none;background-image:url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23333' d='M6 9L1 4h10z'/%3E%3C/svg%3E\");background-repeat:no-repeat;background-position:right 8px center;padding-right:40px}.checkbox-wrapper{display:flex;align-items:center;gap:8px}input[type=checkbox]{width:18px;height:18px;cursor:pointer}.checkbox-label{cursor:pointer;margin:0}.file-upload-container{display:flex;align-items:center;gap:20px;padding:20px;background:#fff;max-width:100%;box-sizing:border-box;flex-wrap:wrap}.material-icons{font-family:Material Icons!important;border-radius:4px;display:inline-block;width:40px;padding:8px;height:40px}.file-field-wrapper{width:100%;margin-top:16px;max-width:100%;box-sizing:border-box}.photo-preview-circle{width:100px;height:100px;border-radius:50%;overflow:hidden;border:2px solid #ddd;cursor:pointer;transition:border-color .2s}.photo-preview-circle:hover{border-color:#3498db}.preview-image,.default-photo{width:100%;height:100%;display:flex;align-items:center;justify-content:center}.preview-image img{width:100%;height:100%;object-fit:cover}.default-photo{background:#f0f0f0;color:#999;font-size:40px}.file-info{display:flex;flex-direction:column;gap:8px}.btn-delete{border:none;border-radius:4px;cursor:pointer;font-size:14px;padding:0}.upload-btn-group{display:flex;align-items:center;border:1px solid #d3d3d3;border-radius:8px;background:#fff;overflow:hidden;width:fit-content}.btn-upload{background:#fff;color:#222;border:none;padding:0 18px;font-size:16px;border-right:1px solid #e0e0e0;border-radius:8px 0 0 8px;outline:none;box-shadow:none;cursor:pointer;height:40px;transition:background .2s}.btn-upload-icon{background:#f5f5f5;border:none;border-radius:0 8px 8px 0;display:flex;align-items:center;justify-content:center;width:48px;height:40px;cursor:pointer;transition:background .2s}.btn-upload-icon i.material-icons{font-size:22px;color:#222}.btn-upload:hover,.btn-upload-icon:hover{background:#f0f0f0}.btn-delete{background:#fff;color:red}.btn-delete:hover{background:#f0f0f0}.file-name{font-size:12px;color:#666;margin:10px 8px 8px}.file-label{font-weight:600;margin-bottom:6px;color:#151d48;font-size:14px;display:block}.radio-label{font-weight:600;margin-bottom:15px;color:#151d48;font-size:14px;display:block}.radio-group{display:flex;gap:20px;align-items:center}.radio-item{display:flex;align-items:center;gap:6px}input[type=radio]{width:18px;height:18px;cursor:pointer;accent-color:#3498db}.radio-option-label{cursor:pointer;margin:0;font-weight:400}.hint{font-size:12px;color:#7f8c8d;margin-top:4px}.error-message{color:#e74c3c;font-size:12px;margin-top:4px}.form-actions{display:flex;gap:8px;align-items:center;justify-content:space-between;gap:12px;padding-top:5px}.btn{padding:8px 20px;border:none;border-radius:7px;font-size:12px;font-weight:600;cursor:pointer;transition:all .2s}.btn-primary{background-color:#006aff;color:#fff}.btn-primary:hover:not(:disabled){background-color:#2980b9}.btn-primary:disabled{background-color:#bdc3c7;cursor:not-allowed}.btn-secondary{background-color:#95a5a6;color:#fff}.btn-secondary:hover{background-color:#7f8c8d}.btn-outline{background-color:#303030;color:#fff}.btn-outline:hover{background-color:#2b2b2b;color:#fff}.month-year-wrapper{position:relative;display:flex;align-items:center;width:100%}.month-year-wrapper .form-control{padding-right:45px}.month-picker-hidden{position:absolute;opacity:0;pointer-events:none;width:0;height:0;border:none;padding:0;margin:0}.month-picker-btn{position:absolute;right:5px;background:transparent;border:none;cursor:pointer;padding:5px;display:flex;align-items:center;justify-content:center;color:#666;transition:color .2s;z-index:1}.month-picker-btn:hover:not(:disabled){color:#3498db}.month-picker-btn:disabled{cursor:not-allowed;opacity:.5}.month-picker-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}.search-select-wrapper{position:relative;width:100%}.search-select-input{padding-right:10px}.search-select-dropdown{position:absolute;top:calc(100% + 4px);left:0;right:auto;min-width:100%;max-width:calc(100vw - 16px);background:#fff;border:1px solid #d3d3d3;border-radius:8px;max-height:220px;overflow-y:auto;box-shadow:0 4px 10px #00000014;z-index:5;padding:6px 0;transform:translate(0);transition:transform .1s ease-out}.search-select-option{padding:8px 12px;cursor:pointer;display:flex;gap:8px;align-items:center;border-bottom:1px solid #f2f2f2}.search-select-option:last-child{border-bottom:none}.search-select-option:hover{background:#f5f9ff}.option-code{color:#0052cc;font-weight:700;min-width:90px}.option-name{color:#151d48;font-weight:500}.time-picker-wrapper{position:relative;display:flex;align-items:center;width:100%}.time-input{padding-right:45px;flex:1}.time-picker-btn{position:absolute;right:5px;background:transparent;border:none;cursor:pointer;padding:5px;display:flex;align-items:center;justify-content:center;color:#666;transition:color .2s;z-index:1}.time-picker-btn:hover:not(:disabled){color:#3498db}.time-picker-btn:disabled{cursor:not-allowed;opacity:.5}.time-picker-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}input[type=time]{cursor:pointer}input[type=time]::-webkit-calendar-picker-indicator{cursor:pointer;opacity:0;position:absolute;right:0;width:100%;height:100%}.date-picker-field{width:100%}.date-picker-field ::ng-deep .mat-mdc-form-field{width:100%}.date-picker-field ::ng-deep .mat-mdc-text-field-wrapper{background-color:#fff}.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing{border-color:#8cbba8}.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:#8cbba8}.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__trailing{border-color:#3498db}.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing{border-color:red!important}.date-picker-field ::ng-deep .mat-mdc-form-field-subscript-wrapper{display:none}.date-picker-field ::ng-deep .mat-mdc-form-field-input-control input{font-family:Poppins!important;font-size:14px;font-weight:400;color:#1f2b41}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: FvEntryFieldComponent, selector: "fv-entry-field", inputs: ["label", "placeholder", "schema", "control", "disabled", "readonly", "type", "allowAlphabetsOnly", "maxLength"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvNumberFieldComponent, selector: "fv-number-field", inputs: ["label", "placeholder", "schema", "control", "disabled", "readonly", "min", "max", "step"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvDropdownComponent, selector: "fv-dropdown", inputs: ["label", "placeholder", "options", "schema", "control", "disabled"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvRadioGroupComponent, selector: "fv-radio-group", inputs: ["label", "control", "options", "disabled", "required", "name"], outputs: ["valueChange"] }, { kind: "component", type: FvCheckboxComponent, selector: "fv-checkbox", inputs: ["label", "control", "disabled", "required"], outputs: ["valueChange"] }, { kind: "component", type: FvDateFieldComponent, selector: "fv-date-field", inputs: ["label", "schema", "control", "disabled", "readonly", "min", "max"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvMonthYearFieldComponent, selector: "fv-month-year-field", inputs: ["label", "schema", "control", "disabled", "readonly", "min", "max"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvFileSelectorComponent, selector: "fv-file-selector", inputs: ["label", "placeholder", "schema", "control", "disabled", "accept", "maxSize"], outputs: ["valueChange", "blur"] }, { kind: "component", type: FvImageSelectorComponent, selector: "fv-image-selector", inputs: ["label", "placeholder", "schema", "control", "disabled", "maxSize"], outputs: ["valueChange", "blur"] }, { kind: "component", type: FvRichTextEditorComponent, selector: "fv-rich-text-editor", inputs: ["label", "placeholder", "schema", "control", "disabled", "readonly", "minHeight", "showToolbar"], outputs: ["valueChange", "blur", "focus"] }, { kind: "component", type: FvNameCodeComponent, selector: "fv-name-code", inputs: ["label", "placeholder", "options", "schema", "control", "disabled"], outputs: ["selectionChange"] }, { kind: "component", type: FvPhoneFieldComponent, selector: "fv-phone-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvUanFieldComponent, selector: "fv-uan-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvPfFieldComponent, selector: "fv-pf-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvEsiFieldComponent, selector: "fv-esi-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvIfscFieldComponent, selector: "fv-ifsc-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvMicrFieldComponent, selector: "fv-micr-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }, { kind: "component", type: FvIbanFieldComponent, selector: "fv-iban-field", inputs: ["label", "control", "disabled", "schema"], outputs: ["blur", "focus"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AddUpdateFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-add-update-form', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FvEntryFieldComponent,
+                        FvNumberFieldComponent,
+                        FvDropdownComponent,
+                        FvRadioGroupComponent,
+                        FvCheckboxComponent,
+                        FvDateFieldComponent,
+                        FvMonthYearFieldComponent,
+                        FvFileSelectorComponent,
+                        FvImageSelectorComponent,
+                        FvRichTextEditorComponent,
+                        FvRichTextEditorComponent,
+                        FvNameCodeComponent,
+                        FvPhoneFieldComponent,
+                        FvUanFieldComponent,
+                        FvPfFieldComponent,
+                        FvEsiFieldComponent,
+                        FvIfscFieldComponent,
+                        FvMicrFieldComponent,
+                        FvIbanFieldComponent,
+                    ], template: `
+    <div class="form-container">
+      <div class="form-header" *ngIf="config.formTitle">
+        <h2>{{ config.formTitle }}</h2>
+      </div>
+
+      <form [formGroup]="form" (ngSubmit)="handleSubmit()" class="dynamic-form">
+        <div *ngFor="let section of config.sections" class="form-section">
+          <h3 class="section-title" *ngIf="section.title">
+            {{ section.title }}
+          </h3>
+
+          <div class="fields-row">
+            <ng-container *ngFor="let column of section.fields">
+              <div
+                class="form-field-wrapper"
+                [ngClass]="'field-' + column.type"
+                [ngStyle]="column.hidden ? { display: 'none' } : {}"
+                [style.grid-column]="'span ' + (column.colSpan || 1)"
+              >
+                <ng-container
+                  *ngIf="
+                    ['text', 'email', 'password'].includes(column.type) &&
+                    !column.hidden
+                  "
+                >
+                  <fv-entry-field
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [type]="
+                      column.type === 'password'
+                        ? 'password'
+                        : column.type === 'email'
+                        ? 'email'
+                        : 'text'
+                    "
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    [readonly]="false"
+                    [allowAlphabetsOnly]="column.allowAlphabetsOnly || false"
+                    [maxLength]="column.maxLength || null"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-entry-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'number' && !column.hidden"
+                >
+                  <fv-number-field
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-number-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'select' && !column.hidden"
+                >
+                  <fv-dropdown
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || 'Select option'"
+                    [options]="column.options || []"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-dropdown>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'checkbox' && !column.hidden"
+                >
+                  <fv-checkbox
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-checkbox>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'radio' && !column.hidden">
+                  <fv-radio-group
+                    [label]="column.label"
+                    [options]="column.options || []"
+                    [control]="getControl(column.name)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-radio-group>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'date' && !column.hidden">
+                  <fv-date-field
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-date-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'month-year' && !column.hidden"
+                >
+                  <fv-month-year-field
+                    [label]="column.label"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleMonthYearChange(column.name, $event)"
+                  >
+                  </fv-month-year-field>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'textarea' && !column.hidden"
+                >
+                  <fv-rich-text-editor
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || ''"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                    (valueChange)="handleFieldChange(column.name, $event)"
+                  >
+                  </fv-rich-text-editor>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'file' && !column.hidden">
+                  <ng-container *ngIf="isImageField(column); else standardFile">
+                    <fv-image-selector
+                      [label]="column.label"
+                      [placeholder]="column.placeholder || 'Select image'"
+                      [control]="getControl(column.name)"
+                      [schema]="getSchema(column)"
+                      [disabled]="column.disabled || false"
+                      (valueChange)="onFileChange($event, column.name)"
+                    >
+                    </fv-image-selector>
+                  </ng-container>
+
+                  <ng-template #standardFile>
+                    <fv-file-selector
+                      [label]="column.label"
+                      [placeholder]="column.placeholder || 'Select file'"
+                      [accept]="column.accept || '*/*'"
+                      [control]="getControl(column.name)"
+                      [schema]="getSchema(column)"
+                      [disabled]="column.disabled || false"
+                      (valueChange)="onFileChange($event, column.name)"
+                    >
+                    </fv-file-selector>
+                  </ng-template>
+                </ng-container>
+
+                <ng-container
+                  *ngIf="column.type === 'name-code' && !column.hidden"
+                >
+                  <fv-name-code
+                    [label]="column.label"
+                    [placeholder]="column.placeholder || 'Search by Code or Name'"
+                    [options]="column.options ? mapSearchOptions(column.options) : []"
+                    [control]="getControl(column.name)"
+                    [schema]="getSchema(column)"
+                    [disabled]="column.disabled || false"
+                  >
+                  </fv-name-code>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'phone' && !column.hidden">
+                  <fv-phone-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-phone-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'uan' && !column.hidden">
+                  <fv-uan-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-uan-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'pf' && !column.hidden">
+                  <fv-pf-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-pf-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'esi' && !column.hidden">
+                  <fv-esi-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-esi-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'ifsc' && !column.hidden">
+                  <fv-ifsc-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-ifsc-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'micr' && !column.hidden">
+                  <fv-micr-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-micr-field>
+                </ng-container>
+
+                <ng-container *ngIf="column.type === 'iban' && !column.hidden">
+                  <fv-iban-field [label]="column.label" [control]="getControl(column.name)" [schema]="getSchema(column)" [disabled]="column.disabled || false"></fv-iban-field>
+                </ng-container>
+              </div>
+            </ng-container>
+          </div>
+        </div>
+
+
+        <div class="form-actions">
+          <button
+            type="submit"
+            class="btn btn-primary"
+            [disabled]="form.invalid && submitted"
+          >
+            {{ config.submitLabel || 'Save' }}
+          </button>
+          <button
+            type="button"
+            class="btn btn-outline"
+            (click)="config.onCancel()"
+          >
+            {{ config.cancelLabel || 'Cancel' }}
+          </button>
+        </div>
+      </form>
+    </div>
+  `, styles: ["@import\"https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap\";@import\"https://fonts.googleapis.com/icon?family=Material+Icons\";*{font-family:Poppins!important}.form-container{background:#f5f5f5;padding:10px;border-radius:8px;margin:0 auto;max-width:100%;overflow-x:hidden;box-sizing:border-box}.error-border{border-color:red!important}.hidden{display:none!important}.form-header{margin-bottom:10px}.form-header h2{margin:0;font-size:20px;font-weight:700;color:#303030}.dynamic-form{background:#fff;padding:10px;border-radius:6px;box-shadow:0 1px 3px #0000001a;max-width:100%;box-sizing:border-box}.form-section{margin-bottom:10px}.section-title{font-size:16px;font-weight:700;color:#303030;margin:0 0 16px;text-transform:uppercase;letter-spacing:.5px}.fields-row{display:grid;grid-template-columns:repeat(5,1fr);gap:16px;width:100%;box-sizing:border-box}.form-field-wrapper{display:flex;position:relative;flex-direction:column;min-width:0;width:100%;box-sizing:border-box}.password-toggle-btn{position:absolute;right:10px;top:32px;background:none;border:none;cursor:pointer;padding:4px;color:#666}.password-toggle-btn:hover{color:#333}.password-toggle-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}@media (min-width: 1200px) and (max-width: 1400px){.fields-row{grid-template-columns:repeat(5,1fr)}.form-control{width:180px;max-width:180px}}@media (max-width: 1200px){.fields-row{grid-template-columns:repeat(3,1fr)}.form-control{width:100%;max-width:100%}}@media (max-width: 992px){.fields-row{grid-template-columns:repeat(2,1fr);gap:12px}}@media (max-width: 768px){.fields-row{grid-template-columns:repeat(2,1fr);gap:10px}}@media (max-width: 640px){.fields-row{grid-template-columns:1fr;gap:12px}.form-field-wrapper{width:100%}}label{font-weight:600;margin-bottom:6px;color:#151d48;font-size:14px}.required{color:#e74c3c;margin-left:2px}.form-control{padding:5px 10px;width:100%;max-width:100%;border:1px solid #8CBBA8;border-radius:8px;background-color:#fff;font-size:14px;font-weight:400;font-family:inherit;color:#1f2b41;transition:border-color .2s,box-shadow .2s;box-sizing:border-box}.form-control:focus{outline:none;border-color:#3498db;box-shadow:0 0 0 3px #3498db1a}.form-control:disabled{background-color:#ecf0f1;cursor:not-allowed}textarea.form-control{resize:vertical;min-height:100px}select.form-control{cursor:pointer;appearance:none;background-image:url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23333' d='M6 9L1 4h10z'/%3E%3C/svg%3E\");background-repeat:no-repeat;background-position:right 8px center;padding-right:40px}.checkbox-wrapper{display:flex;align-items:center;gap:8px}input[type=checkbox]{width:18px;height:18px;cursor:pointer}.checkbox-label{cursor:pointer;margin:0}.file-upload-container{display:flex;align-items:center;gap:20px;padding:20px;background:#fff;max-width:100%;box-sizing:border-box;flex-wrap:wrap}.material-icons{font-family:Material Icons!important;border-radius:4px;display:inline-block;width:40px;padding:8px;height:40px}.file-field-wrapper{width:100%;margin-top:16px;max-width:100%;box-sizing:border-box}.photo-preview-circle{width:100px;height:100px;border-radius:50%;overflow:hidden;border:2px solid #ddd;cursor:pointer;transition:border-color .2s}.photo-preview-circle:hover{border-color:#3498db}.preview-image,.default-photo{width:100%;height:100%;display:flex;align-items:center;justify-content:center}.preview-image img{width:100%;height:100%;object-fit:cover}.default-photo{background:#f0f0f0;color:#999;font-size:40px}.file-info{display:flex;flex-direction:column;gap:8px}.btn-delete{border:none;border-radius:4px;cursor:pointer;font-size:14px;padding:0}.upload-btn-group{display:flex;align-items:center;border:1px solid #d3d3d3;border-radius:8px;background:#fff;overflow:hidden;width:fit-content}.btn-upload{background:#fff;color:#222;border:none;padding:0 18px;font-size:16px;border-right:1px solid #e0e0e0;border-radius:8px 0 0 8px;outline:none;box-shadow:none;cursor:pointer;height:40px;transition:background .2s}.btn-upload-icon{background:#f5f5f5;border:none;border-radius:0 8px 8px 0;display:flex;align-items:center;justify-content:center;width:48px;height:40px;cursor:pointer;transition:background .2s}.btn-upload-icon i.material-icons{font-size:22px;color:#222}.btn-upload:hover,.btn-upload-icon:hover{background:#f0f0f0}.btn-delete{background:#fff;color:red}.btn-delete:hover{background:#f0f0f0}.file-name{font-size:12px;color:#666;margin:10px 8px 8px}.file-label{font-weight:600;margin-bottom:6px;color:#151d48;font-size:14px;display:block}.radio-label{font-weight:600;margin-bottom:15px;color:#151d48;font-size:14px;display:block}.radio-group{display:flex;gap:20px;align-items:center}.radio-item{display:flex;align-items:center;gap:6px}input[type=radio]{width:18px;height:18px;cursor:pointer;accent-color:#3498db}.radio-option-label{cursor:pointer;margin:0;font-weight:400}.hint{font-size:12px;color:#7f8c8d;margin-top:4px}.error-message{color:#e74c3c;font-size:12px;margin-top:4px}.form-actions{display:flex;gap:8px;align-items:center;justify-content:space-between;gap:12px;padding-top:5px}.btn{padding:8px 20px;border:none;border-radius:7px;font-size:12px;font-weight:600;cursor:pointer;transition:all .2s}.btn-primary{background-color:#006aff;color:#fff}.btn-primary:hover:not(:disabled){background-color:#2980b9}.btn-primary:disabled{background-color:#bdc3c7;cursor:not-allowed}.btn-secondary{background-color:#95a5a6;color:#fff}.btn-secondary:hover{background-color:#7f8c8d}.btn-outline{background-color:#303030;color:#fff}.btn-outline:hover{background-color:#2b2b2b;color:#fff}.month-year-wrapper{position:relative;display:flex;align-items:center;width:100%}.month-year-wrapper .form-control{padding-right:45px}.month-picker-hidden{position:absolute;opacity:0;pointer-events:none;width:0;height:0;border:none;padding:0;margin:0}.month-picker-btn{position:absolute;right:5px;background:transparent;border:none;cursor:pointer;padding:5px;display:flex;align-items:center;justify-content:center;color:#666;transition:color .2s;z-index:1}.month-picker-btn:hover:not(:disabled){color:#3498db}.month-picker-btn:disabled{cursor:not-allowed;opacity:.5}.month-picker-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}.search-select-wrapper{position:relative;width:100%}.search-select-input{padding-right:10px}.search-select-dropdown{position:absolute;top:calc(100% + 4px);left:0;right:auto;min-width:100%;max-width:calc(100vw - 16px);background:#fff;border:1px solid #d3d3d3;border-radius:8px;max-height:220px;overflow-y:auto;box-shadow:0 4px 10px #00000014;z-index:5;padding:6px 0;transform:translate(0);transition:transform .1s ease-out}.search-select-option{padding:8px 12px;cursor:pointer;display:flex;gap:8px;align-items:center;border-bottom:1px solid #f2f2f2}.search-select-option:last-child{border-bottom:none}.search-select-option:hover{background:#f5f9ff}.option-code{color:#0052cc;font-weight:700;min-width:90px}.option-name{color:#151d48;font-weight:500}.time-picker-wrapper{position:relative;display:flex;align-items:center;width:100%}.time-input{padding-right:45px;flex:1}.time-picker-btn{position:absolute;right:5px;background:transparent;border:none;cursor:pointer;padding:5px;display:flex;align-items:center;justify-content:center;color:#666;transition:color .2s;z-index:1}.time-picker-btn:hover:not(:disabled){color:#3498db}.time-picker-btn:disabled{cursor:not-allowed;opacity:.5}.time-picker-btn .material-icons{font-size:20px;width:auto;height:auto;padding:0}input[type=time]{cursor:pointer}input[type=time]::-webkit-calendar-picker-indicator{cursor:pointer;opacity:0;position:absolute;right:0;width:100%;height:100%}.date-picker-field{width:100%}.date-picker-field ::ng-deep .mat-mdc-form-field{width:100%}.date-picker-field ::ng-deep .mat-mdc-text-field-wrapper{background-color:#fff}.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing{border-color:#8cbba8}.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing{border-color:#8cbba8}.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__leading,.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__notch,.date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__trailing{border-color:#3498db}.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,.date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing{border-color:red!important}.date-picker-field ::ng-deep .mat-mdc-form-field-subscript-wrapper{display:none}.date-picker-field ::ng-deep .mat-mdc-form-field-input-control input{font-family:Poppins!important;font-size:14px;font-weight:400;color:#1f2b41}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i0.ElementRef }], propDecorators: { config: [{
+                type: Input
+            }], validationError: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-update-form.component.js","sourceRoot":"","sources":["../../../../../projects/fv-controls/src/lib/add-update-form/add-update-form.component.ts"],"names":[],"mappings":"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","sourcesContent":["export type FieldType =\r\n  | 'text'\r\n  | 'email'\r\n  | 'number'\r\n  | 'select'\r\n  | 'name-code'\r\n  | 'checkbox'\r\n  | 'textarea'\r\n  | 'date'\r\n  | 'password'\r\n  | 'radio'\r\n  | 'file'\r\n  | 'month-year'\r\n  | 'phone'\r\n  | 'uan'\r\n  | 'pf'\r\n  | 'esi'\r\n  | 'ifsc'\r\n  | 'micr'\r\n  | 'iban';\r\nexport type ValidationType =\r\n  | 'required'\r\n  | 'email'\r\n  | 'minLength'\r\n  | 'maxLength'\r\n  | 'pattern'\r\n  | 'min'\r\n  | 'max'\r\n  | 'custom';\r\n\r\nexport interface FieldValidation {\r\n  type: ValidationType;\r\n  value?: any; // For minLength, maxLength, min, max, pattern\r\n  message?: string; // Custom error message\r\n  validator?: (value: any, formGroup?: FormGroup) => boolean; // For custom validation\r\n}\r\n\r\nexport interface FormColumn {\r\n  name: string;\r\n  label: string;\r\n  type: FieldType;\r\n  placeholder?: string;\r\n  required?: boolean;\r\n  options?: { label: string; value: any }[]; // For select fields\r\n  validations?: FieldValidation[];\r\n  value?: any; // Default value\r\n  disabled?: boolean;\r\n  className?: string;\r\n  hidden?: boolean;\r\n  hint?: string;\r\n  colSpan?: number;\r\n  onChange?: (value: any, formGroup: FormGroup) => void;\r\n  accept?: string; // For file input (e.g., 'image/*')\r\n  filePreview?: boolean; // Show image preview`\r\n  showTimePicker?: boolean; // Show time picker for text fields\r\n  allowAlphabetsOnly?: boolean;\r\n  maxLength?: number;\r\n}\r\n\r\nexport interface FormSection {\r\n  title?: string; // Section heading (e.g., \"PERSONAL INFORMATION\")\r\n  fields: FormColumn[];\r\n}\r\n\r\nexport interface FormConfig {\r\n  sections: FormSection[];\r\n  submitLabel?: string;\r\n  resetLabel?: string;\r\n  onSubmit: (data: any) => void;\r\n  onReset?: () => void;\r\n  onCancel: () => void;\r\n  cancelLabel?: string;\r\n  formTitle?: string;\r\n  maxColsPerRow?: number;\r\n}\r\n\r\n// add-update-form.component.ts\r\nimport {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  OnDestroy,\r\n  AfterViewInit,\r\n  ElementRef,\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport {\r\n  AbstractControl,\r\n  FormBuilder,\r\n  FormControl,\r\n  FormGroup,\r\n  ReactiveFormsModule,\r\n  Validators,\r\n} from '@angular/forms';\r\nimport { Subscription } from 'rxjs';\r\nimport { distinctUntilChanged } from 'rxjs/operators';\r\n// Import your library modules\r\nimport { FvEntryFieldComponent } from '../fv-entry-field/fv-entry-field.component';\r\nimport { FvNumberFieldComponent } from '../fv-number-field/fv-number-field.component';\r\nimport { FvDropdownComponent } from '../fv-dropdown/fv-dropdown.component';\r\nimport { FvRadioGroupComponent } from '../fv-radio-group/fv-radio-group.component';\r\nimport { FvCheckboxComponent } from '../fv-checkbox/fv-checkbox.component';\r\nimport { FvDateFieldComponent } from '../fv-date-field/fv-date-field.component';\r\nimport { FvMonthYearFieldComponent } from '../fv-month-year-field/fv-month-year-field.component';\r\nimport { FvFileSelectorComponent } from '../fv-file-selector/fv-file-selector.component';\r\nimport { FvImageSelectorComponent } from '../fv-image-selector/fv-image-selector.component';\r\nimport { FvRichTextEditorComponent } from '../fv-rich-text-editor/fv-rich-text-editor.component';\r\nimport { FvNameCodeComponent } from '../fv-name-code/fv-name-code.component';\r\nimport { FvPhoneFieldComponent } from '../fv-phone-field/fv-phone-field.component';\r\nimport { FvUanFieldComponent } from '../fv-uan-field/fv-uan-field.component';\r\nimport { FvPfFieldComponent } from '../fv-pf-field/fv-pf-field.component';\r\nimport { FvEsiFieldComponent } from '../fv-esi-field/fv-esi-field.component';\r\nimport { FvIfscFieldComponent } from '../fv-ifsc-field/fv-ifsc-field.component';\r\nimport { FvMicrFieldComponent } from '../fv-micr-field/fv-micr-field.component';\r\nimport { FvIbanFieldComponent } from '../fv-iban-field/fv-iban-field.component';\r\n\r\n// Import Validation Types\r\nimport { ValidationSchema, ValidationRule } from '@fovestta/validation-engine';\r\n@Component({\r\n  selector: 'lib-add-update-form',\r\n  standalone: true,\r\n  imports: [\r\n    CommonModule,\r\n    ReactiveFormsModule,\r\n    FvEntryFieldComponent,\r\n    FvNumberFieldComponent,\r\n    FvDropdownComponent,\r\n    FvRadioGroupComponent,\r\n    FvCheckboxComponent,\r\n    FvDateFieldComponent,\r\n    FvMonthYearFieldComponent,\r\n    FvFileSelectorComponent,\r\n    FvImageSelectorComponent,\r\n    FvRichTextEditorComponent,\r\n    FvRichTextEditorComponent,\r\n    FvNameCodeComponent,\r\n    FvPhoneFieldComponent,\r\n    FvUanFieldComponent,\r\n    FvPfFieldComponent,\r\n    FvEsiFieldComponent,\r\n    FvIfscFieldComponent,\r\n    FvMicrFieldComponent,\r\n    FvIbanFieldComponent,\r\n  ],\r\n  template: `\r\n    <div class=\"form-container\">\r\n      <div class=\"form-header\" *ngIf=\"config.formTitle\">\r\n        <h2>{{ config.formTitle }}</h2>\r\n      </div>\r\n\r\n      <form [formGroup]=\"form\" (ngSubmit)=\"handleSubmit()\" class=\"dynamic-form\">\r\n        <div *ngFor=\"let section of config.sections\" class=\"form-section\">\r\n          <h3 class=\"section-title\" *ngIf=\"section.title\">\r\n            {{ section.title }}\r\n          </h3>\r\n\r\n          <div class=\"fields-row\">\r\n            <ng-container *ngFor=\"let column of section.fields\">\r\n              <div\r\n                class=\"form-field-wrapper\"\r\n                [ngClass]=\"'field-' + column.type\"\r\n                [ngStyle]=\"column.hidden ? { display: 'none' } : {}\"\r\n                [style.grid-column]=\"'span ' + (column.colSpan || 1)\"\r\n              >\r\n                <ng-container\r\n                  *ngIf=\"\r\n                    ['text', 'email', 'password'].includes(column.type) &&\r\n                    !column.hidden\r\n                  \"\r\n                >\r\n                  <fv-entry-field\r\n                    [label]=\"column.label\"\r\n                    [placeholder]=\"column.placeholder || ''\"\r\n                    [type]=\"\r\n                      column.type === 'password'\r\n                        ? 'password'\r\n                        : column.type === 'email'\r\n                        ? 'email'\r\n                        : 'text'\r\n                    \"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    [readonly]=\"false\"\r\n                    [allowAlphabetsOnly]=\"column.allowAlphabetsOnly || false\"\r\n                    [maxLength]=\"column.maxLength || null\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-entry-field>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'number' && !column.hidden\"\r\n                >\r\n                  <fv-number-field\r\n                    [label]=\"column.label\"\r\n                    [placeholder]=\"column.placeholder || ''\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-number-field>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'select' && !column.hidden\"\r\n                >\r\n                  <fv-dropdown\r\n                    [label]=\"column.label\"\r\n                    [placeholder]=\"column.placeholder || 'Select option'\"\r\n                    [options]=\"column.options || []\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-dropdown>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'checkbox' && !column.hidden\"\r\n                >\r\n                  <fv-checkbox\r\n                    [label]=\"column.label\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-checkbox>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'radio' && !column.hidden\">\r\n                  <fv-radio-group\r\n                    [label]=\"column.label\"\r\n                    [options]=\"column.options || []\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-radio-group>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'date' && !column.hidden\">\r\n                  <fv-date-field\r\n                    [label]=\"column.label\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-date-field>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'month-year' && !column.hidden\"\r\n                >\r\n                  <fv-month-year-field\r\n                    [label]=\"column.label\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleMonthYearChange(column.name, $event)\"\r\n                  >\r\n                  </fv-month-year-field>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'textarea' && !column.hidden\"\r\n                >\r\n                  <fv-rich-text-editor\r\n                    [label]=\"column.label\"\r\n                    [placeholder]=\"column.placeholder || ''\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                    (valueChange)=\"handleFieldChange(column.name, $event)\"\r\n                  >\r\n                  </fv-rich-text-editor>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'file' && !column.hidden\">\r\n                  <ng-container *ngIf=\"isImageField(column); else standardFile\">\r\n                    <fv-image-selector\r\n                      [label]=\"column.label\"\r\n                      [placeholder]=\"column.placeholder || 'Select image'\"\r\n                      [control]=\"getControl(column.name)\"\r\n                      [schema]=\"getSchema(column)\"\r\n                      [disabled]=\"column.disabled || false\"\r\n                      (valueChange)=\"onFileChange($event, column.name)\"\r\n                    >\r\n                    </fv-image-selector>\r\n                  </ng-container>\r\n\r\n                  <ng-template #standardFile>\r\n                    <fv-file-selector\r\n                      [label]=\"column.label\"\r\n                      [placeholder]=\"column.placeholder || 'Select file'\"\r\n                      [accept]=\"column.accept || '*/*'\"\r\n                      [control]=\"getControl(column.name)\"\r\n                      [schema]=\"getSchema(column)\"\r\n                      [disabled]=\"column.disabled || false\"\r\n                      (valueChange)=\"onFileChange($event, column.name)\"\r\n                    >\r\n                    </fv-file-selector>\r\n                  </ng-template>\r\n                </ng-container>\r\n\r\n                <ng-container\r\n                  *ngIf=\"column.type === 'name-code' && !column.hidden\"\r\n                >\r\n                  <fv-name-code\r\n                    [label]=\"column.label\"\r\n                    [placeholder]=\"column.placeholder || 'Search by Code or Name'\"\r\n                    [options]=\"column.options ? mapSearchOptions(column.options) : []\"\r\n                    [control]=\"getControl(column.name)\"\r\n                    [schema]=\"getSchema(column)\"\r\n                    [disabled]=\"column.disabled || false\"\r\n                  >\r\n                  </fv-name-code>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'phone' && !column.hidden\">\r\n                  <fv-phone-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-phone-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'uan' && !column.hidden\">\r\n                  <fv-uan-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-uan-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'pf' && !column.hidden\">\r\n                  <fv-pf-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-pf-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'esi' && !column.hidden\">\r\n                  <fv-esi-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-esi-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'ifsc' && !column.hidden\">\r\n                  <fv-ifsc-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-ifsc-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'micr' && !column.hidden\">\r\n                  <fv-micr-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-micr-field>\r\n                </ng-container>\r\n\r\n                <ng-container *ngIf=\"column.type === 'iban' && !column.hidden\">\r\n                  <fv-iban-field [label]=\"column.label\" [control]=\"getControl(column.name)\" [schema]=\"getSchema(column)\" [disabled]=\"column.disabled || false\"></fv-iban-field>\r\n                </ng-container>\r\n              </div>\r\n            </ng-container>\r\n          </div>\r\n        </div>\r\n\r\n\r\n        <div class=\"form-actions\">\r\n          <button\r\n            type=\"submit\"\r\n            class=\"btn btn-primary\"\r\n            [disabled]=\"form.invalid && submitted\"\r\n          >\r\n            {{ config.submitLabel || 'Save' }}\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"btn btn-outline\"\r\n            (click)=\"config.onCancel()\"\r\n          >\r\n            {{ config.cancelLabel || 'Cancel' }}\r\n          </button>\r\n        </div>\r\n      </form>\r\n    </div>\r\n  `,\r\n  styles: `\r\n\r\n  @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap');\r\n  @import url('https://fonts.googleapis.com/icon?family=Material+Icons');\r\n    *{\r\n      font-family: \"Poppins\" !important;\r\n    }\r\n    .form-container {\r\n      background: #f5f5f5;\r\n      padding: 10px;\r\n      border-radius: 8px;\r\n      margin: 0 auto;\r\n      max-width: 100%;\r\n      overflow-x: hidden;\r\n      box-sizing: border-box;\r\n    }\r\n\r\n    .error-border {\r\n     border-color: red !important;\r\n    }\r\n\r\n    .hidden{\r\n      display:none !important;\r\n    }\r\n\r\n    .form-header {\r\n      margin-bottom: 10px;\r\n    }\r\n\r\n    .form-header h2 {\r\n      margin: 0;\r\n      font-size: 20px;\r\n      font-weight: 700;\r\n      color: #303030;\r\n    }\r\n\r\n    .dynamic-form {\r\n      background: white;\r\n      padding: 10px;\r\n      border-radius: 6px;\r\n      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);\r\n      max-width: 100%;\r\n      box-sizing: border-box;\r\n    }\r\n\r\n    .form-section {\r\n      margin-bottom:10px;\r\n    }\r\n\r\n    .section-title {\r\n      font-size: 16px;\r\n      font-weight: 700;\r\n      color: #303030;\r\n      margin: 0 0 16px 0;\r\n      text-transform: uppercase;\r\n      letter-spacing: 0.5px;\r\n    }\r\n\r\n    .fields-row {\r\n      display: grid;\r\n      grid-template-columns: repeat(5,1fr);\r\n      gap: 16px;\r\n      width: 100%;\r\n      box-sizing: border-box;\r\n    }\r\n\r\n    .form-field-wrapper {\r\n      display: flex;\r\n       position: relative;\r\n      flex-direction: column;\r\n      min-width: 0;\r\n      width: 100%;\r\n      box-sizing: border-box;\r\n    }\r\n\r\n    .password-toggle-btn {\r\n  position: absolute;\r\n  right: 10px;\r\n  top: 32px;\r\n  background: none;\r\n  border: none;\r\n  cursor: pointer;\r\n  padding: 4px;\r\n  color: #666;\r\n}\r\n\r\n.password-toggle-btn:hover {\r\n  color: #333;\r\n}\r\n\r\n.password-toggle-btn .material-icons {\r\n  font-size: 20px;\r\n  width: auto;\r\n  height: auto;\r\n  padding: 0;\r\n}\r\n\r\n    @media (min-width: 1200px) and (max-width: 1400px) {\r\n      .fields-row {\r\n        grid-template-columns: repeat(5,1fr);\r\n      }\r\n      .form-control {\r\n        width: 180px;\r\n        max-width: 180px;\r\n      }\r\n    }\r\n\r\n    @media (max-width: 1200px) {\r\n      .fields-row {\r\n        grid-template-columns: repeat(3,1fr);\r\n      }\r\n      .form-control {\r\n        width: 100%;\r\n        max-width: 100%;\r\n      }\r\n    }\r\n\r\n    @media (max-width: 992px) {\r\n      .fields-row {\r\n        grid-template-columns: repeat(2,1fr);\r\n        gap: 12px;\r\n      }\r\n    }\r\n\r\n    @media (max-width: 768px) {\r\n      .fields-row {\r\n        grid-template-columns: repeat(2,1fr);\r\n        gap: 10px;\r\n      }\r\n    }\r\n\r\n    @media (max-width: 640px) {\r\n      .fields-row {\r\n        grid-template-columns: 1fr;\r\n        gap: 12px;\r\n      }\r\n      .form-field-wrapper {\r\n        width: 100%;\r\n      }\r\n    }\r\n\r\n    label {\r\n      font-weight: 600;\r\n      margin-bottom: 6px;\r\n      color: #151D48;\r\n      font-size: 14px;\r\n    }\r\n\r\n    .required {\r\n      color: #e74c3c;\r\n      margin-left: 2px;\r\n    }\r\n\r\n    .form-control {\r\n      padding: 5px 10px;\r\n      width: 100%;\r\n      max-width: 100%;\r\n      border: 1px solid #8CBBA8;\r\n      border-radius: 8px;\r\n      background-color: #ffffff;\r\n      font-size: 14px;\r\n      font-weight: 400;\r\n      font-family: inherit;\r\n      color: #1f2b41;\r\n      transition: border-color 0.2s, box-shadow 0.2s;\r\n      box-sizing: border-box;\r\n    }\r\n\r\n    .form-control:focus {\r\n      outline: none;\r\n      border-color: #3498db;\r\n      box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);\r\n    }\r\n\r\n    .form-control:disabled {\r\n      background-color: #ecf0f1;\r\n      cursor: not-allowed;\r\n    }\r\n\r\n    textarea.form-control {\r\n      resize: vertical;\r\n      min-height: 100px;\r\n    }\r\n\r\n    select.form-control {\r\n      cursor: pointer;\r\n      appearance: none;\r\n      background-image: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23333' d='M6 9L1 4h10z'/%3E%3C/svg%3E\");\r\n      background-repeat: no-repeat;\r\n      background-position: right 8px center;\r\n      padding-right: 40px;\r\n    }\r\n\r\n    .checkbox-wrapper {\r\n      display: flex;\r\n      align-items: center;\r\n      gap: 8px;\r\n    }\r\n\r\n    input[type=\"checkbox\"] {\r\n      width: 18px;\r\n      height: 18px;\r\n      cursor: pointer;\r\n    }\r\n\r\n    .checkbox-label {\r\n      cursor: pointer;\r\n      margin: 0;\r\n    }\r\n\r\n    .file-upload-container {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 20px;\r\n  padding: 20px;\r\n  background: white;\r\n  max-width: 100%;\r\n  box-sizing: border-box;\r\n  flex-wrap: wrap;\r\n}\r\n\r\n.material-icons {\r\n  font-family: 'Material Icons' !important;\r\n  border-radius: 4px;\r\n  display: inline-block;\r\n  width: 40px;\r\n  padding: 8px;\r\n  height: 40px;\r\n}\r\n\r\n.file-field-wrapper {\r\n  width: 100%;\r\n  margin-top: 16px;\r\n  max-width: 100%;\r\n  box-sizing: border-box;\r\n}\r\n\r\n.photo-preview-circle {\r\n  width: 100px;\r\n  height: 100px;\r\n  border-radius: 50%;\r\n  overflow: hidden;\r\n  border: 2px solid #ddd;\r\n  cursor: pointer;\r\n  transition: border-color 0.2s;\r\n}\r\n\r\n.photo-preview-circle:hover {\r\n  border-color: #3498db;\r\n}\r\n\r\n.preview-image, .default-photo {\r\n  width: 100%;\r\n  height: 100%;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n}\r\n\r\n.preview-image img {\r\n  width: 100%;\r\n  height: 100%;\r\n  object-fit: cover;\r\n}\r\n\r\n.default-photo {\r\n  background: #f0f0f0;\r\n  color: #999;\r\n  font-size: 40px;\r\n}\r\n\r\n.file-info {\r\n  display: flex;\r\n  flex-direction: column;\r\n  gap: 8px;\r\n}\r\n.btn-delete {\r\n  border: none;\r\n  border-radius: 4px;\r\n  cursor: pointer;\r\n  font-size: 14px;\r\n  padding: 0px;\r\n}\r\n\r\n.upload-btn-group {\r\n  display: flex;\r\n  align-items: center;\r\n  border: 1px solid #d3d3d3;\r\n  border-radius: 8px;\r\n  background: #fff;\r\n  overflow: hidden;\r\n  width: fit-content;\r\n}\r\n\r\n.btn-upload {\r\n  background: #fff;\r\n  color: #222;\r\n  border: none;\r\n  padding: 0 18px;\r\n  font-size: 16px;\r\n  border-right: 1px solid #e0e0e0;\r\n  border-radius: 8px 0 0 8px;\r\n  outline: none;\r\n  box-shadow: none;\r\n  cursor: pointer;\r\n  height: 40px;\r\n  transition: background 0.2s;\r\n}\r\n\r\n.btn-upload-icon {\r\n  background: #f5f5f5;\r\n  border: none;\r\n  border-radius: 0 8px 8px 0;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  width: 48px;\r\n  height: 40px;\r\n  cursor: pointer;\r\n  transition: background 0.2s;\r\n}\r\n\r\n.btn-upload-icon i.material-icons {\r\n  font-size: 22px;\r\n  color: #222;\r\n}\r\n\r\n.btn-upload:hover, .btn-upload-icon:hover {\r\n  background: #f0f0f0;\r\n}\r\n\r\n.btn-delete {\r\n  background: white;\r\n  color: red;\r\n}\r\n\r\n.btn-delete:hover {\r\n  background: #f0f0f0;\r\n}\r\n\r\n.file-name {\r\n  font-size: 12px;\r\n  color: #666;\r\n  margin: 8px;\r\n  margin-top: 10px;\r\n}\r\n\r\n.file-label {\r\n    font-weight: 600;\r\n    margin-bottom: 6px;\r\n    color: #151d48;\r\n    font-size: 14px;\r\n  display: block;\r\n}\r\n\r\n    .radio-label {\r\n  font-weight: 600;\r\n  margin-bottom: 15px;\r\n  color: #151D48;\r\n  font-size: 14px;\r\n  display: block;\r\n}\r\n\r\n.radio-group {\r\n  display: flex;\r\n  gap: 20px;\r\n  align-items: center;\r\n}\r\n\r\n.radio-item {\r\n  display: flex;\r\n  align-items: center;\r\n  gap: 6px;\r\n}\r\n\r\ninput[type=\"radio\"] {\r\n  width: 18px;\r\n  height: 18px;\r\n  cursor: pointer;\r\n  accent-color: #3498db;\r\n}\r\n\r\n.radio-option-label {\r\n  cursor: pointer;\r\n  margin: 0;\r\n  font-weight: 400;\r\n}\r\n\r\n    .hint {\r\n      font-size: 12px;\r\n      color: #7f8c8d;\r\n      margin-top: 4px;\r\n    }\r\n\r\n    .error-message {\r\n      color: #e74c3c;\r\n      font-size: 12px;\r\n      margin-top: 4px;\r\n    }\r\n\r\n    .form-actions {\r\n      display: flex;\r\n      gap: 8px;\r\n      align-items: center;\r\n      justify-content: space-between;\r\n      gap: 12px;\r\n      padding-top: 5px;\r\n    }\r\n\r\n    .btn {\r\n      padding: 8px 20px;\r\n      border: none;\r\n      border-radius: 7px;\r\n      font-size: 12px;\r\n      font-weight: 600;\r\n      cursor: pointer;\r\n      transition: all 0.2s;\r\n    }\r\n\r\n    .btn-primary {\r\n      background-color: #006AFF;\r\n      color: white;\r\n    }\r\n\r\n    .btn-primary:hover:not(:disabled) {\r\n      background-color: #2980b9;\r\n    }\r\n\r\n    .btn-primary:disabled {\r\n      background-color: #bdc3c7;\r\n      cursor: not-allowed;\r\n    }\r\n\r\n    .btn-secondary {\r\n      background-color: #95a5a6;\r\n      color: white;\r\n    }\r\n\r\n    .btn-secondary:hover {\r\n      background-color: #7f8c8d;\r\n    }\r\n\r\n    .btn-outline {\r\n      background-color: #303030;\r\n      color: white;\r\n    }\r\n\r\n    .btn-outline:hover {\r\n      background-color: #2b2b2bff;\r\n      color: white;\r\n    }\r\n\r\n    .month-year-wrapper {\r\n      position: relative;\r\n      display: flex;\r\n      align-items: center;\r\n      width: 100%;\r\n    }\r\n\r\n    .month-year-wrapper .form-control {\r\n      padding-right: 45px;\r\n    }\r\n\r\n    .month-picker-hidden {\r\n      position: absolute;\r\n      opacity: 0;\r\n      pointer-events: none;\r\n      width: 0;\r\n      height: 0;\r\n      border: none;\r\n      padding: 0;\r\n      margin: 0;\r\n    }\r\n\r\n    .month-picker-btn {\r\n      position: absolute;\r\n      right: 5px;\r\n      background: transparent;\r\n      border: none;\r\n      cursor: pointer;\r\n      padding: 5px;\r\n      display: flex;\r\n      align-items: center;\r\n      justify-content: center;\r\n      color: #666;\r\n      transition: color 0.2s;\r\n      z-index: 1;\r\n    }\r\n\r\n    .month-picker-btn:hover:not(:disabled) {\r\n      color: #3498db;\r\n    }\r\n\r\n    .month-picker-btn:disabled {\r\n      cursor: not-allowed;\r\n      opacity: 0.5;\r\n    }\r\n\r\n    .month-picker-btn .material-icons {\r\n      font-size: 20px;\r\n      width: auto;\r\n      height: auto;\r\n      padding: 0;\r\n    }\r\n\r\n    .search-select-wrapper {\r\n      position: relative;\r\n      width: 100%;\r\n    }\r\n\r\n    .search-select-input {\r\n      padding-right: 10px;\r\n    }\r\n\r\n    .search-select-dropdown {\r\n      position: absolute;\r\n      top: calc(100% + 4px);\r\n      left: 0;\r\n      right: auto;\r\n      min-width: 100%;\r\n      max-width: calc(100vw - 16px);\r\n      background: white;\r\n      border: 1px solid #d3d3d3;\r\n      border-radius: 8px;\r\n      max-height: 220px;\r\n      overflow-y: auto;\r\n      box-shadow: 0 4px 10px rgba(0,0,0,0.08);\r\n      z-index: 5;\r\n      padding: 6px 0;\r\n      transform: translateX(0);\r\n      transition: transform 0.1s ease-out;\r\n    }\r\n\r\n    .search-select-option {\r\n      padding: 8px 12px;\r\n      cursor: pointer;\r\n      display: flex;\r\n      gap: 8px;\r\n      align-items: center;\r\n      border-bottom: 1px solid #f2f2f2;\r\n    }\r\n\r\n    .search-select-option:last-child {\r\n      border-bottom: none;\r\n    }\r\n\r\n    .search-select-option:hover {\r\n      background: #f5f9ff;\r\n    }\r\n\r\n    .option-code {\r\n      color: #0052cc;\r\n      font-weight: 700;\r\n      min-width: 90px;\r\n    }\r\n\r\n    .option-name {\r\n      color: #151d48;\r\n      font-weight: 500;\r\n    }\r\n\r\n    .time-picker-wrapper {\r\n      position: relative;\r\n      display: flex;\r\n      align-items: center;\r\n      width: 100%;\r\n    }\r\n\r\n    .time-input {\r\n      padding-right: 45px;\r\n      flex: 1;\r\n    }\r\n\r\n    .time-picker-btn {\r\n      position: absolute;\r\n      right: 5px;\r\n      background: transparent;\r\n      border: none;\r\n      cursor: pointer;\r\n      padding: 5px;\r\n      display: flex;\r\n      align-items: center;\r\n      justify-content: center;\r\n      color: #666;\r\n      transition: color 0.2s;\r\n      z-index: 1;\r\n    }\r\n\r\n    .time-picker-btn:hover:not(:disabled) {\r\n      color: #3498db;\r\n    }\r\n\r\n    .time-picker-btn:disabled {\r\n      cursor: not-allowed;\r\n      opacity: 0.5;\r\n    }\r\n\r\n    .time-picker-btn .material-icons {\r\n      font-size: 20px;\r\n      width: auto;\r\n      height: auto;\r\n      padding: 0;\r\n    }\r\n\r\n    input[type=\"time\"] {\r\n      cursor: pointer;\r\n    }\r\n\r\n    input[type=\"time\"]::-webkit-calendar-picker-indicator {\r\n      cursor: pointer;\r\n      opacity: 0;\r\n      position: absolute;\r\n      right: 0;\r\n      width: 100%;\r\n      height: 100%;\r\n    }\r\n\r\n    .date-picker-field {\r\n      width: 100%;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mat-mdc-form-field {\r\n      width: 100%;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mat-mdc-text-field-wrapper {\r\n      background-color: #ffffff;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing {\r\n      border-color: #8CBBA8;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__leading,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__notch,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined:not(.mdc-text-field--disabled) .mdc-notched-outline__trailing {\r\n      border-color: #8CBBA8;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__leading,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__notch,\r\n    .date-picker-field ::ng-deep .mdc-text-field--outlined.mdc-text-field--focused .mdc-notched-outline__trailing {\r\n      border-color: #3498db;\r\n    }\r\n\r\n    .date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__leading,\r\n    .date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__notch,\r\n    .date-picker-field.error-border ::ng-deep .mdc-text-field--outlined .mdc-notched-outline__trailing {\r\n      border-color: red !important;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mat-mdc-form-field-subscript-wrapper {\r\n      display: none;\r\n    }\r\n\r\n    .date-picker-field ::ng-deep .mat-mdc-form-field-input-control input {\r\n      font-family: \"Poppins\" !important;\r\n      font-size: 14px;\r\n      font-weight: 400;\r\n      color: #1f2b41;\r\n    }\r\n  `,\r\n})\r\nexport class AddUpdateFormComponent\r\n  implements OnInit, OnDestroy, AfterViewInit {\r\n  @Input() config!: FormConfig;\r\n  @Output() validationError = new EventEmitter<string>();\r\n  form!: FormGroup;\r\n  submitted = false;\r\n  private filePreviews: Map<string, string> = new Map();\r\n  private fileNames: Map<string, string> = new Map();\r\n  private valueChangeSubscriptions: Subscription[] = [];\r\n  private passwordVisibility: Map<string, boolean> = new Map();\r\n  private searchQueries: Map<string, string> = new Map();\r\n\r\n  constructor(\r\n    private fb: FormBuilder,\r\n    private hostRef: ElementRef<HTMLElement>\r\n  ) { }\r\n\r\n  ngOnInit() {\r\n    this.initializeForm();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    // Lifecycle hook - can be used for datepicker initialization if needed\r\n  }\r\n\r\n  getColumnWidth(column: FormColumn): string {\r\n    const maxCols = this.config.maxColsPerRow || 5;\r\n    const colSpan = Math.min(column.colSpan || 1, maxCols);\r\n    return `calc(${(colSpan / maxCols) * 100}% - 16px)`;\r\n  }\r\n\r\n  getControl(name: string): FormControl {\r\n    return this.form.get(name) as FormControl;\r\n  }\r\n\r\n  // 2. HELPER: Convert your FieldValidation[] to the library's ValidationSchema\r\n  getSchema(column: FormColumn): ValidationSchema {\r\n    const rules: ValidationRule[] = [];\r\n    const errorPriority: string[] = [];\r\n\r\n    if (column.validations) {\r\n      column.validations.forEach((v) => {\r\n        switch (v.type) {\r\n          case 'required':\r\n            rules.push({\r\n              name: 'required',\r\n              params: { enabled: true },\r\n              errorKey: 'ERR_REQUIRED',\r\n            });\r\n            errorPriority.push('required');\r\n            break;\r\n          case 'email':\r\n            rules.push({\r\n              name: 'regex',\r\n              params: {\r\n                pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$',\r\n              },\r\n              errorKey: 'ERR_REGEX_MISMATCH',\r\n            });\r\n            errorPriority.push('regex');\r\n            break;\r\n          case 'minLength':\r\n            rules.push({\r\n              name: 'minLength',\r\n              params: { value: v.value },\r\n              errorKey: 'ERR_MIN_LENGTH',\r\n            });\r\n            errorPriority.push('minLength');\r\n            break;\r\n          case 'maxLength':\r\n            rules.push({\r\n              name: 'maxLength',\r\n              params: { value: v.value },\r\n              errorKey: 'ERR_MAX_LENGTH',\r\n            });\r\n            errorPriority.push('maxLength');\r\n            break;\r\n          case 'pattern':\r\n            rules.push({\r\n              name: 'regex',\r\n              params: { pattern: v.value },\r\n              errorKey: 'ERR_REGEX_MISMATCH',\r\n            });\r\n            errorPriority.push('regex');\r\n            break;\r\n          case 'min':\r\n            rules.push({\r\n              name: 'min',\r\n              params: { value: v.value },\r\n              errorKey: 'ERR_MIN_VALUE',\r\n            });\r\n            errorPriority.push('min');\r\n            break;\r\n          case 'max':\r\n            rules.push({\r\n              name: 'max',\r\n              params: { value: v.value },\r\n              errorKey: 'ERR_MAX_VALUE',\r\n            });\r\n            errorPriority.push('max');\r\n            break;\r\n        }\r\n      });\r\n    }\r\n\r\n    // Map 'name-code' to 'Dropdown' or similar for validation schema purposes if needed\r\n    let controlType = column.type;\r\n    if (column.type === 'name-code') {\r\n      controlType = 'select'; // Treat as select for schema lookup if library expects 'select' or 'Dropdown'\r\n    }\r\n\r\n    return {\r\n      controlType: controlType,\r\n      errorPriority: errorPriority,\r\n      rules: rules,\r\n    };\r\n  }\r\n\r\n  isImageField(column: FormColumn): boolean {\r\n    return (\r\n      column.type === 'file' &&\r\n      (column.accept?.startsWith('image') || column.filePreview === true)\r\n    );\r\n  }\r\n\r\n  initializeForm() {\r\n    this.submitted = false;\r\n    const formGroupConfig: any = {};\r\n\r\n    this.config.sections.forEach((section) => {\r\n      section.fields.forEach((column) => {\r\n        let initialValue = column.value || '';\r\n\r\n        // Format month-year fields to YYYY-MM format\r\n        if (column.type === 'month-year' && initialValue) {\r\n          initialValue = this.formatMonthYearValue(initialValue);\r\n        }\r\n\r\n        formGroupConfig[column.name] = [\r\n          { value: initialValue, disabled: column.disabled || false },\r\n          null, // We'll set validators after form creation\r\n        ];\r\n\r\n        // If it's a file field with an existing value, set the preview\r\n        if (column.type === 'file' && column.value) {\r\n          this.filePreviews.set(column.name, column.value);\r\n          // Extract filename from URL or base64\r\n          const fileName = this.extractFileName(column.value);\r\n          if (fileName) {\r\n            this.fileNames.set(column.name, fileName);\r\n          }\r\n        }\r\n\r\n        // Initialize search display for name-code fields - No longer needed as FvNameCode handles display internally\r\n        /* if (column.type === 'name-code' && initialValue && column.options) {\r\n             // Logic moved to component\r\n        } */\r\n      });\r\n    });\r\n\r\n    this.form = this.fb.group(formGroupConfig);\r\n\r\n    this.config.sections.forEach((section) => {\r\n      section.fields.forEach((column) => {\r\n        const validators = this.buildValidators(column.validations, this.form);\r\n        if (validators.length > 0) {\r\n          this.form.get(column.name)?.setValidators(validators);\r\n          this.form.get(column.name)?.updateValueAndValidity();\r\n        }\r\n      });\r\n    });\r\n\r\n    // Subscribe to value changes for all fields to trigger onChange handlers\r\n    Object.keys(this.form.controls).forEach((key) => {\r\n      const control = this.form.get(key);\r\n      if (control) {\r\n        const subscription = control.valueChanges\r\n          .pipe(distinctUntilChanged())\r\n          .subscribe((value) => {\r\n            const column = this.getColumnByName(key);\r\n            if (column?.onChange) {\r\n              column.onChange(value, this.form);\r\n            }\r\n          });\r\n        this.valueChangeSubscriptions.push(subscription);\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    // Clean up all subscriptions to prevent memory leaks\r\n    this.valueChangeSubscriptions.forEach((sub) => sub.unsubscribe());\r\n    this.valueChangeSubscriptions = [];\r\n  }\r\n\r\n  handleFieldChange(fieldName: string, eventValue?: any) {\r\n    const column = this.getColumnByName(fieldName);\r\n    const formControl = this.form.get(fieldName);\r\n\r\n    // Format month-year fields (especially expiryDate) to YYYY-MM\r\n    if (column?.type === 'month-year' && eventValue) {\r\n      const formattedValue = this.formatMonthYearValue(eventValue);\r\n      if (formControl && formattedValue !== eventValue) {\r\n        formControl.setValue(formattedValue, { emitEvent: false });\r\n        eventValue = formattedValue;\r\n      }\r\n    }\r\n\r\n    if (column?.onChange) {\r\n      // Use the event value directly (what the user just selected/typed)\r\n      // This ensures we have the correct value even if form control hasn't updated yet\r\n      const valueToPass =\r\n        eventValue !== undefined ? eventValue : this.form.get(fieldName)?.value;\r\n      const onChangeFn = column.onChange; // Store the function reference\r\n\r\n      // Store the selected value - this is what the user chose\r\n      const selectedValue = valueToPass;\r\n\r\n      // Ensure the form control has the selected value before calling onChange\r\n      if (formControl && selectedValue !== undefined) {\r\n        if (formControl.value !== selectedValue) {\r\n          formControl.setValue(selectedValue, { emitEvent: false });\r\n        }\r\n      }\r\n\r\n      // Call onChange with the selected value\r\n      if (onChangeFn) {\r\n        onChangeFn(selectedValue, this.form);\r\n      }\r\n\r\n      // Restore the value for the field that triggered the change if it was cleared by onChange\r\n      // This is critical: if onChange clears the field that was just changed, we restore it\r\n      // Only restore if we had a non-empty value (empty string, null, undefined are not restored)\r\n      if (\r\n        formControl &&\r\n        selectedValue !== undefined &&\r\n        selectedValue !== null &&\r\n        selectedValue !== ''\r\n      ) {\r\n        // Use setTimeout with 0 delay to run after any synchronous operations in onChange\r\n        setTimeout(() => {\r\n          // Check if the value was cleared or changed\r\n          const currentValue = formControl.value;\r\n          // If the value doesn't match what was selected, restore it\r\n          // This handles the case where onChange cleared the field unintentionally\r\n          if (currentValue !== selectedValue) {\r\n            formControl.setValue(selectedValue, { emitEvent: false });\r\n          }\r\n        }, 0);\r\n      }\r\n    }\r\n  }\r\n\r\n  formatMonthYearValue(value: string): string {\r\n    if (!value) return value;\r\n    // Normalize to YYYY-MM\r\n    if (value.match(/^\\d{2}-\\d{4}$/)) {\r\n      const [month, year] = value.split('-');\r\n      return `${year}-${month}`;\r\n    }\r\n    // If already in YYYY-MM format, return as is\r\n    return value;\r\n  }\r\n\r\n  parseMonthYearValue(value: string): string {\r\n    if (!value) return value;\r\n    // Display and picker both use YYYY-MM; normalize MM-YYYY if present\r\n    if (value.match(/^\\d{2}-\\d{4}$/)) {\r\n      const [month, year] = value.split('-');\r\n      return `${year}-${month}`;\r\n    }\r\n    return value;\r\n  }\r\n\r\n  handleMonthYearChange(fieldName: string, value: string) {\r\n    // Format the input value to YYYY-MM format\r\n    let formattedValue = value;\r\n\r\n    // If it's in MM-YYYY format, convert to YYYY-MM\r\n    if (formattedValue.match(/^\\d{2}-\\d{4}$/)) {\r\n      const [month, year] = formattedValue.split('-');\r\n      formattedValue = `${year}-${month}`;\r\n    }\r\n    // If it's in YYYYMM format (no dash), convert to YYYY-MM\r\n    else if (formattedValue.match(/^\\d{6}$/)) {\r\n      const year = formattedValue.substring(0, 4);\r\n      const month = formattedValue.substring(4, 6);\r\n      formattedValue = `${year}-${month}`;\r\n    }\r\n    // If it's already in YYYY-MM format, leave as is\r\n    else if (formattedValue.match(/^\\d{4}-\\d{2}$/)) {\r\n      // Already in correct format\r\n    }\r\n    // If user is typing, allow partial input\r\n    else if (formattedValue.match(/^\\d{1,6}$/)) {\r\n      // Allow partial input while typing\r\n    }\r\n\r\n    const formControl = this.form.get(fieldName);\r\n    if (formControl && formattedValue !== value) {\r\n      formControl.setValue(formattedValue, { emitEvent: false });\r\n    }\r\n\r\n    this.handleFieldChange(fieldName, formattedValue);\r\n  }\r\n\r\n  handleMonthYearBlur(fieldName: string) {\r\n    const formControl = this.form.get(fieldName);\r\n    if (!formControl) return;\r\n\r\n    const value = formControl.value || '';\r\n    // Ensure the value is in YYYY-MM format on blur\r\n    if (value && !value.match(/^\\d{4}-\\d{2}$/)) {\r\n      // Try to parse and format\r\n      const formatted = this.formatMonthYearValue(value);\r\n      if (formatted !== value) {\r\n        formControl.setValue(formatted, { emitEvent: false });\r\n      }\r\n    }\r\n  }\r\n\r\n  handleMonthYearPickerChange(fieldName: string, value: string) {\r\n    // Month picker outputs YYYY-MM; just normalize\r\n    const formattedValue = this.formatMonthYearValue(value);\r\n    const formControl = this.form.get(fieldName);\r\n    if (formControl) {\r\n      formControl.setValue(formattedValue, { emitEvent: false });\r\n      this.handleFieldChange(fieldName, formattedValue);\r\n    }\r\n  }\r\n\r\n  getMonthYearPickerValue(fieldName: string): string {\r\n    const formControl = this.form.get(fieldName);\r\n    if (!formControl) return '';\r\n    const value = formControl.value || '';\r\n    // Display and picker both expect YYYY-MM\r\n    return this.parseMonthYearValue(value);\r\n  }\r\n\r\n  openMonthPicker(fieldName: string) {\r\n    const monthInput = document.getElementById(\r\n      fieldName + '_picker'\r\n    ) as HTMLInputElement;\r\n    if (monthInput && monthInput.type === 'month') {\r\n      // Update the picker value before opening\r\n      const currentValue = this.getMonthYearPickerValue(fieldName);\r\n      if (currentValue) {\r\n        monthInput.value = currentValue;\r\n      }\r\n      // Try modern showPicker API first, fallback to click\r\n      if (monthInput.showPicker) {\r\n        monthInput.showPicker();\r\n      } else {\r\n        monthInput.focus();\r\n        monthInput.click();\r\n      }\r\n    }\r\n  }\r\n\r\n  getColumnByName(name: string): FormColumn | undefined {\r\n    return this.config.sections\r\n      .flatMap((s) => s.fields)\r\n      .find((c) => c.name === name);\r\n  }\r\n\r\n  getFileFields(fields: FormColumn[]): FormColumn[] {\r\n    return fields.filter((f) => f.type === 'file');\r\n  }\r\n\r\n  getNonFileFields(fields: FormColumn[]): FormColumn[] {\r\n    return fields.filter((f) => f.type !== 'file');\r\n  }\r\n\r\n  togglePasswordVisibility(fieldName: string) {\r\n    const current = this.passwordVisibility.get(fieldName) || false;\r\n    this.passwordVisibility.set(fieldName, !current);\r\n  }\r\n  hasRequiredValidation(column: FormColumn): boolean {\r\n    return column.validations?.some((v) => v.type === 'required') || false;\r\n  }\r\n\r\n  isPasswordVisible(fieldName: string): boolean {\r\n    return this.passwordVisibility.get(fieldName) || false;\r\n  }\r\n\r\n  buildValidators(\r\n    validations?: FieldValidation[],\r\n    formGroup?: FormGroup\r\n  ): any[] {\r\n    if (!validations) return [];\r\n\r\n    const validators: any[] = [];\r\n    validations.forEach((validation) => {\r\n      switch (validation.type) {\r\n        case 'required':\r\n          validators.push(Validators.required);\r\n          break;\r\n        case 'email':\r\n          validators.push(Validators.email);\r\n          break;\r\n        case 'minLength':\r\n          validators.push(Validators.minLength(validation.value));\r\n          break;\r\n        case 'maxLength':\r\n          validators.push(Validators.maxLength(validation.value));\r\n          break;\r\n        case 'min':\r\n          validators.push(Validators.min(validation.value));\r\n          break;\r\n        case 'max':\r\n          validators.push(Validators.max(validation.value));\r\n          break;\r\n        case 'pattern':\r\n          validators.push(Validators.pattern(validation.value));\r\n          break;\r\n        case 'custom':\r\n          if (validation.validator) {\r\n            validators.push((control: AbstractControl) => {\r\n              const isValid = validation.validator!(control.value, formGroup);\r\n              return isValid ? null : { custom: true };\r\n            });\r\n          }\r\n          break;\r\n      }\r\n    });\r\n    return validators;\r\n  }\r\n\r\n  triggerFileUpload(fieldName: string) {\r\n    document.getElementById('fileInput_' + fieldName)?.click();\r\n  }\r\n\r\n  openTimePicker(fieldName: string) {\r\n    const timeInput = document.getElementById(fieldName) as HTMLInputElement;\r\n    if (timeInput && timeInput.type === 'time') {\r\n      // Try modern showPicker API first, fallback to click\r\n      if (timeInput.showPicker) {\r\n        timeInput.showPicker();\r\n      } else {\r\n        timeInput.focus();\r\n        timeInput.click();\r\n      }\r\n    }\r\n  }\r\n\r\n  onFileChange(event: any, fieldName: string) {\r\n    const file: File = event.target.files[0];\r\n    if (file) {\r\n      this.fileNames.set(fieldName, file.name);\r\n      const reader = new FileReader();\r\n      reader.readAsDataURL(file);\r\n      reader.onload = () => {\r\n        const base64String = reader.result as string;\r\n        this.filePreviews.set(fieldName, base64String);\r\n        this.form.get(fieldName)?.setValue(base64String);\r\n\r\n        // Trigger onChange handler for file fields\r\n        const column = this.getColumnByName(fieldName);\r\n        if (column?.onChange) {\r\n          column.onChange(base64String, this.form);\r\n        }\r\n      };\r\n    }\r\n  }\r\n\r\n  extractFileName(value: string): string {\r\n    if (!value) return '';\r\n\r\n    // If it's a URL, extract filename from URL\r\n    if (value.startsWith('http')) {\r\n      const parts = value.split('/');\r\n      return parts[parts.length - 1];\r\n    }\r\n\r\n    // If it's base64, return a generic name\r\n    if (value.startsWith(`data:image`)) {\r\n      return 'uploaded-image.jpg';\r\n    }\r\n\r\n    return 'existing-photo.jpg';\r\n  }\r\n\r\n  getFilePreview(fieldName: string): string | null {\r\n    return this.filePreviews.get(fieldName) || null;\r\n  }\r\n\r\n  getFileName(fieldName: string): string | null {\r\n    return this.fileNames.get(fieldName) || null;\r\n  }\r\n\r\n  mapSearchOptions(options: any[]): any[] {\r\n    return options.map(opt => ({\r\n      code: opt.code || opt.value,\r\n      name: opt.name || opt.label || opt.value,\r\n      value: opt.value\r\n    }));\r\n  }\r\n\r\n\r\n  deleteFile(fieldName: string) {\r\n    this.filePreviews.delete(fieldName);\r\n    this.fileNames.delete(fieldName);\r\n    this.form.get(fieldName)?.setValue('');\r\n\r\n    // Trigger onChange handler when file is deleted\r\n    const column = this.getColumnByName(fieldName);\r\n    if (column?.onChange) {\r\n      column.onChange('', this.form);\r\n    }\r\n  }\r\n\r\n  handleSubmit() {\r\n    this.submitted = true;\r\n    if (this.form.invalid) {\r\n      // Mark all fields as touched to show red borders\r\n      Object.keys(this.form.controls).forEach((key) => {\r\n        this.form.get(key)?.markAsTouched();\r\n      });\r\n\r\n      // Count only required fields that are invalid\r\n      const allColumns = this.config.sections.flatMap((s) => s.fields);\r\n      const invalidRequiredCount = Object.keys(this.form.controls).filter(\r\n        (key) => {\r\n          const control = this.form.get(key);\r\n          if (!control?.invalid) return false;\r\n\r\n          // Check if this field has required validation\r\n          const column = allColumns.find((c) => c.name === key);\r\n          return (\r\n            column?.validations?.some((v) => v.type === 'required') || false\r\n          );\r\n        }\r\n      ).length;\r\n\r\n      // Only emit if there are required fields missing\r\n      if (invalidRequiredCount > 0) {\r\n        this.validationError.emit(\r\n          `Please fill all required fields marked with *. ${invalidRequiredCount} field(s) need attention.`\r\n        );\r\n      }\r\n      return;\r\n    }\r\n\r\n    const formData = this.form.getRawValue();\r\n    this.config.onSubmit(formData);\r\n  }\r\n\r\n  handleReset() {\r\n    this.submitted = false;\r\n    this.form.reset();\r\n    if (this.config.onReset) {\r\n      this.config.onReset();\r\n    }\r\n  }\r\n\r\n  isFieldInvalid(fieldName: string): boolean {\r\n    const field = this.form.get(fieldName);\r\n    return !!(field && field.invalid && this.submitted);\r\n  }\r\n\r\n  getErrorMessage(fieldName: string): string {\r\n    const field = this.form.get(fieldName);\r\n    if (!field?.errors) return '';\r\n\r\n    // Check if there's a custom message from validations\r\n    const allColumns = this.config.sections.flatMap((s) => s.fields);\r\n    const column = allColumns.find((c) => c.name === fieldName);\r\n    // Check for custom validation error\r\n    if (field.errors['custom']) {\r\n      const customValidation = column?.validations?.find(\r\n        (v) => v.type === 'custom'\r\n      );\r\n      return customValidation?.message || 'Invalid field';\r\n    }\r\n\r\n    // Check if there's a custom message from validations\r\n    const errorKeys = Object.keys(field.errors);\r\n    for (const key of errorKeys) {\r\n      const validation = column?.validations?.find((v) => v.type === key);\r\n      if (validation?.message) {\r\n        return validation.message;\r\n      }\r\n    }\r\n    // Default error messages\r\n    if (field.errors['required']) {\r\n      return `${column?.label} is required`;\r\n    }\r\n    if (field.errors['email']) return 'Invalid email format';\r\n    if (field.errors['minlength'])\r\n      return `Minimum length is ${field.errors['minlength'].requiredLength}`;\r\n    if (field.errors['maxlength'])\r\n      return `Maximum length is ${field.errors['maxlength'].requiredLength}`;\r\n    if (field.errors['min'])\r\n      return `Minimum value is ${field.errors['min'].min}`;\r\n    if (field.errors['max'])\r\n      return `Maximum value is ${field.errors['max'].max}`;\r\n    if (field.errors['pattern']) return 'Invalid format';\r\n    return 'Invalid field';\r\n  }\r\n}\r\n"]}