@rangertechnologies/ngnxt 2.1.152 → 2.1.153

package/esm2022/lib/pages/builder/element/element.component.mjs

@@ -113,7 +113,33 @@ export class ElementComponent {
     // AP - 26FEB25 - Added ngOnChanges to handle changes in bookletJSON
     ngOnChanges(changes) {
         if (changes['bookletJSON'] && changes['bookletJSON'].currentValue) {
-            if (this.bookletJSON && (this.bookletJSON !== '')) {
+            if (this.bookletJSON && this.bookletJSON !== '') {
+                // AP-28MAY25 - Check and transform `action` if it's in Existing format
+                if (this.bookletJSON.questionbook &&
+                    this.bookletJSON.questionbook.action &&
+                    typeof this.bookletJSON.questionbook.action === 'string') {
+                    try {
+                        const parsedActions = JSON.parse(this.bookletJSON.questionbook.action);
+                        // AP-28MAY25 Assign specific positionPercent based on action name
+                        const newActions = parsedActions.map((item, index) => {
+                            const positionPercent = item.name === 'Cancel' ? 3 :
+                                item.name === 'Save' ? 14 : (10 + index * 10);
+                            return {
+                                ...item,
+                                positionPercent: positionPercent,
+                                width: 100,
+                                textColor: "#ffffff",
+                                borderRadius: 6,
+                                id: index + 1
+                            };
+                        });
+                        // AP-28MAY25 Replace the old action string with the newly formatted array
+                        this.bookletJSON.questionbook.action = newActions;
+                    }
+                    catch (e) {
+                        console.error("Error parsing action JSON string:", e);
+                    }
+                }
                 this.initializeForm();
             }
             else {
@@ -139,7 +165,7 @@ export class ElementComponent {
         const bookQuestionsMap = this.bookletJSON.bookQuestionsMap;
         const bookQuestionsMapKeys = Object.keys(bookQuestionsMap);
         if (bookQuestionsMapKeys.length === 0)
-            return; // Check for empty object early
+            return;
         for (const key of bookQuestionsMapKeys) {
             const subQuestions = bookQuestionsMap[key]?.subQuestions;
             if (Array.isArray(subQuestions)) {
@@ -452,4 +478,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], templateMode: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element.component.js","sourceRoot":"","sources":["../../../../../../../projects/nxt-app/src/lib/pages/builder/element/element.component.ts","../../../../../../../projects/nxt-app/src/lib/pages/builder/element/element.component.html"],"names":[],"mappings":"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","sourcesContent":["// AP 22JAN25 - form preview and All form elements\nimport { Component, EventEmitter, Input, Output, SimpleChanges } from '@angular/core';\nimport { FormBuilderService } from '../../../services/form-builder.service'\nimport { VERSION } from '../../../../environments/version';\n\n@Component({\n  selector: 'app-element',\n  templateUrl: './element.component.html',\n  styleUrls: ['./element.component.css'],\n})\n\nexport class ElementComponent {\n\n  //@Output() elementButtonClicked = new EventEmitter<string>();\n  @Input() bookletJSON: any;\n  @Input() bookletId: any;\n  @Output() templateMode = new EventEmitter<boolean>();\n  field: any;\n  formElements: any[] = [];\n  elements: any[] = [];\n  bookId: string;\n  sections = {\n    basic: true,    // Basic Elements open by default\n    advanced: true // Advanced Elements closed by default\n  };\n  basicElements: any[] = [];\n  advancedElements: any[] = [];\n  //elementDisabledArray: any;\n  version = VERSION.version; //SKS10MAR25 get version from environment/version.ts \n  book: any;\n  selectedElement: any = null;\n  isSelectTablePopup: boolean = false;\n  currentType: string;\n  addTable: boolean = true;\n  dots = Array(6);\n  draggedIndex: number | null = null;\n  templateSelected = false;\n\n  //subscription: any;\n  constructor(private formBuilderService: FormBuilderService) {\n  }\n//  AP-06MAR25 New Design Change Elements Basic , Advanced\n// AP-06MAR25 Add RichText Area\n// AP-12MAR25 Add Date\nngOnInit() {\n  this.basicElements = [\n  \n  { \"type\": \"Text\", \"img\": \"Text\", \"label\": \"Text\" },\n  { \"type\": \"Number\", \"img\": \"Number\", \"label\": \"Number\" },\n  { \"type\": \"Label\", \"img\": \"Label\", \"label\": \"Label\" },\n  { \"type\": \"Email\", \"img\": \"Email\", \"label\": \"Email\" },\n  { \"type\": \"Date\", \"img\": \"Date\", \"label\": \"Date\" },\n  { \"type\": \"Time\", \"img\": \"Time\", \"label\": \"Time\" },\n  { \"type\": \"DateTime\", \"img\": \"DateTime\", \"label\": \"DateTime\" },\n  { \"type\": \"Calendar\", \"img\": \"Calendar\", \"label\": \"Calendar\" },\n  { \"type\": \"File\", \"img\": \"File\", \"label\": \"Files\" },\n  { \"type\": \"Image\", \"img\": \"Image\", \"label\": \"Image\" },\n  { \"type\": \"Checkbox\", \"img\": \"CheckBox\", \"label\": \"Checkbox\" },\n  { \"type\": \"Radio\", \"img\": \"Radio\", \"label\": \"Radio\" },\n  { \"type\": \"Dropdown\", \"img\": \"Drop\", \"label\": \"Dropdown\" },\n  { \"type\": \"TextArea\", \"img\": \"TextArea\", \"label\": \"Text Area\" },\n  { \"type\": \"RichTextArea\", \"img\": \"RichText\", \"label\": \"Rich Text\" }, \n  \n    ];\n\n    this.advancedElements = [\n  { \"type\": \"Line\", \"img\": \"line\", \"label\": \"Line\" },\n  { \"type\": \"Space\", \"img\": \"space\", \"label\": \"Space\" },  \n  { \"type\": \"Boolean\", \"img\": \"Boolean\", \"label\": \"Boolean\" },\n  { \"type\": \"Book\", \"img\": \"Search\", \"label\": \"Book\" },\n  { \"type\": \"List\", \"img\": \"Search\", \"label\": \"List\" },\n  { \"type\": \"Table\", \"img\": \"Table\", \"label\": \"Table\" },\n  { \"type\": \"Button\", \"img\": \"Button\", \"label\": \"Button\" }\n    ];\n    // this.elementDisabledArray = {\n    //   Table: [\n    //     'Book', 'Calendar',\"Boolean\", 'List', 'Table', 'Checkbox', 'Radio', \n    //     'Dropdown', 'TextArea', 'RichTextArea', 'Number', 'Label', 'Image', \n    //     'Email', 'Date', 'Time', 'DateTime', 'Line', 'Space'\n    //   ]\n    // };\n    \n    this.formBuilderService.formElements$.subscribe(elements => {\n      setTimeout(() => {\n        this.formElements = elements.map(field => ({ ...field }));\n      }, 0);\n    });\n    if (this.bookletJSON && (this.bookletJSON !== '')) {\n      this.initializeForm();\n    } else {\n      this.formBuilderService.newBook()\n    }\n    // AP-12MAR25 - Added to handle bookletId\n    if (this.bookletId) {\n      localStorage.setItem('unique_id', this.bookletId);\n      \n    }\n    this.book = this.formBuilderService.getBook();\n    this.formBuilderService.selectedElement$.subscribe(index => {\n      const elements = this.formBuilderService.getElements();\n      if (index >= 0) {\n        this.selectedElement = elements[index];\n      }\n      // SKS19MAR25 for fieldMeta checking\n      if (this.selectedElement?.type === 'Table') {\n        this.selectedElement['fieldsMeta'] = typeof this.selectedElement.fieldsMeta === 'string' ? this.selectedElement.fieldsMeta : JSON.stringify(this.selectedElement['fieldsMeta'] || []);\n      }\n      // this.formElements = [...elements]\n    });\n    this.formBuilderService.addElementWithId();\n  }\n\n  // Add these methods\n  toggleSection(section: 'basic' | 'advanced') {\n    this.sections[section] = !this.sections[section];\n  }\n\n  isSectionOpen(section: string): boolean {\n    return this.sections[section];\n  }\n\n  // AP - 26FEB25 - Added ngOnChanges to handle changes in bookletJSON\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['bookletJSON'] && changes['bookletJSON'].currentValue) {\n      if (this.bookletJSON && (this.bookletJSON !== '')) {\n        this.initializeForm();\n      } else {\n        this.formBuilderService.newBook()\n      }\n    }\n  }\n  // AP-08APR25 Template is selected, update form elements and emit template mode\n  onTemplateSelected(event: { selectedTemplate: any; elements: any[] }) {\n    this.formBuilderService.clearElements();\n    event.elements.forEach(el => this.formBuilderService.addElement(el));\n\n    // Emit template mode to parent\n   this.templateMode.emit(true);\n  }\n\n  private initializeForm() {\n    if (!this.bookletJSON || !this.bookletJSON.bookQuestionsMap) {\n      console.warn(\"Invalid bookletJSON structure\");\n      return;\n    }\n    this.formElements = []\n    this.formBuilderService.clearElements();\n    this.formBuilderService.intializeBook(this.bookletJSON);\n  \n    const bookQuestionsMap = this.bookletJSON.bookQuestionsMap;\n    const bookQuestionsMapKeys = Object.keys(bookQuestionsMap);\n  \n    if (bookQuestionsMapKeys.length === 0) return; // Check for empty object early\n  \n    for (const key of bookQuestionsMapKeys) {\n      const subQuestions = bookQuestionsMap[key]?.subQuestions;\n  \n      if (Array.isArray(subQuestions)) {\n        subQuestions.forEach((subQuestion) => {\n           // AP-04APR24 If subQuestion.style exists as a string and is empty, replace it with a default style object\n          if (typeof subQuestion.style === \"string\" && subQuestion.style.trim() === \"\") {\n            subQuestion.style = {\n              \"labelClass\": null,\n              \"labelStyle\": null,\n              \"labelValueStyle\": null,\n              \"inputClass\": null,\n              \"inputStyle\": null,\n              \"showLabel\": true,\n              \"bookStyle\": null,\n              \"direction\": \"ltr\",\n              \"questionStyle\": null\n            };\n          }\n        });\n      }\n    }\n    this.formElements = this.formBuilderService.getElements();\n  }\n\n  // Add this method to handle element selection\n  selectElement(index: number) {\n    this.selectedFieldIndex = index; // element is selected\n    this.formBuilderService.setSelectedElement(index);\n    this.book = this.formBuilderService.getBook();\n    //const element = this.formElements[index];\n    // this.elementButtonClicked.emit(element.type);  \n  }\n  //selectedIndex: number | null = null;\n  selectedFieldIndex: number | null = null; // element is cleared\n\n  selectHeading(event: any) {\n    this.formBuilderService.selectHeading(event); //AP-10MAR25 Updates the selected heading in the service  \n    this.book = this.formBuilderService.getBook(); //AP-10MAR25 Retrieves the updated book/form data \n  }\n// AP-17APR25 generateUiId \n  generateUiId() {\n    return this.formBuilderService.addElementWithId();  \n  }  \n\n  addElement(type: string): void {\n    const unique_id = this.generateUiId();\n    this.currentType = type\n    if (this.selectedElement?.type === 'Table' && this.addTable) {\n      this.isSelectTablePopup = true\n    } else {\n      const newElement = {\n        action: null,\n        id: unique_id,\n        uid: unique_id,\n        type,\n        name: null,\n        questionText: null,\n        question: null,\n        helpText: null,\n        errorMessage: null,\n        isReadOnly: false,\n        isHidden: false,\n        required: false,\n        referenceField: null,\n        additionalRichContent: null,\n        groupName: null,\n        isDateBackward: false,\n        title: null,\n        subTitle: null,\n        size: 12,\n        isDateForward: false,\n        isOptional: false,\n        isTitle: false,\n        nextQuestion: null,\n        allowedFileExtensions: null,\n        questionNumber: this.formBuilderService.getElements().length + 1,\n        order: this.formElements.length + 1,\n        questionBookId: this.bookletId,\n        parentQuestion: null,\n        fieldsMeta: [],\n        recordTypeName: null,\n        recordTypeId: null,\n        trackingId: null,\n        dateText: null,\n        timeText: null,\n        recordId: null,\n        qbReference: null,\n        qbReferenceQuestions: null,\n        questionBookSubTitle: null,\n        style: {\n          labelClass: null,\n          labelStyle: null,\n          labelValueStyle: null,\n          inputClass: null,\n          inputStyle: null,\n          showLabel: true,\n          bookStyle: null,\n          direction: 'ltr',\n          questionStyle: null,\n        },\n        subText: this.getDefaultSubText(), \n        imageData: null,\n        boolean: false,\n        options: type === 'Dropdown' || type === 'Radio' || type === 'Checkbox' ? [] : null,\n        imageSize:  type === 'Image' ? { width: 150, height: 150 } : null,\n        tableConfig: type === 'Table' ? {\n          isNosIndicator: true,\n          addInlineRecord: true,\n          isPagination: true,\n          actionButton: true,\n          isDeleteRow: true,\n          isEditRow: true,\n          searchBar: true,\n          isButtons: true,\n          itemsPerPage: 10,\n        } : null,\n      };\n      this.formBuilderService.addElement(newElement);\n      this.formElements = this.formBuilderService.getElements();\n      // SKS19MAR25 fieldsmeta check\n      this.formElements = this.formElements.map(ele => {\n        if (ele.type === 'Table') {\n          ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n            ? ele.fieldsMeta\n            : JSON.stringify(ele.fieldsMeta || []);\n        }\n        return ele;\n      });\n      this.addTable = true\n    }\n  }\n  // AP-07MAY25 - Added to handle default subText\n  getDefaultSubText() {\n    const defaultData = {\n      endpoint: null,\n      variable: null,\n      field: null,\n      defaultField: null,\n      sourceQuestionId: null,\n      valueField: null,\n      labelField: null,\n      isDependentField: false,\n      dependentValue: null,\n      queryField: null,\n      queryValue: null,\n      queryValueReference: null,\n      uniqueKey: null,\n      \n    };\n  \n    const isEmpty = Object.values(defaultData).every(\n      val => val === null || val === false\n    );\n  \n    return isEmpty ? null : defaultData;\n  }  \n  // Remove an element by index\n  removeElement(field: any, index: number): void {\n    this.formBuilderService.removeElementComponent(field.id);\n    this.formElements = this.formBuilderService.getElements();\n    // SKS19MAR25 fieldsmeta check\n    this.formElements = this.formElements.map(ele => {\n      if (ele.type === 'Table') {\n        ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n          ? ele.fieldsMeta\n          : JSON.stringify(ele.fieldsMeta || []);\n      }\n      return ele;\n    });\n  }\n\n  onDragStart(event: DragEvent, index: number) {\n    this.draggedIndex = index;\n    event.dataTransfer?.setData('text/plain', index.toString());\n  }\n\n  // Allow dropping by preventing default\n  onDragOver(event: DragEvent, index: number) {\n    event.preventDefault();\n  }\n\n  // Handle drop event\n  onDrop(event: DragEvent, dropIndex: number) {\n    event.preventDefault();\n\n    if (this.draggedIndex === null || this.draggedIndex === dropIndex) return;\n\n    const draggedItem = this.formElements[this.draggedIndex];\n\n    // Remove dragged item from old position and insert it in new position\n    this.formElements.splice(this.draggedIndex, 1);\n    this.formElements.splice(dropIndex, 0, draggedItem);\n\n  //AP-28MAR25 Update questionNumber dynamically based on new order\n  this.formElements.forEach((element, index) => {\n    element.questionNumber = index + 1;\n  });\n\n    // Reset dragged index\n    this.draggedIndex = null;\n\n    // Notify service about the update\n    this.formBuilderService.updateElementsOrder(this.formElements);\n  }\n  \n  toggleBoolean(field: any): void {\n    field.boolean = !field.boolean;\n  }\n  getFontStyles(field: any): any {\n    const styles: any = {\n      'font-family': field.font || 'Helvetica Neue',\n      'font-weight': field.fontWeight || '400',\n      'font-size': field.fontSize || '14px',\n      'width': field.size ? `${(field.size / 12) * 100}%` : '100%',\n      'text-align': field.textAlign || 'left',\n      'border-radius': '5px',\n      'border-width': field.lineWidth ? `${field.lineWidth}px` : '1px',\n      // 'border-style': field.lineStyle?.toLowerCase() || 'solid',\n      'color': field.fontColor || '#000000',\n      // 'border-color': field.color || '#EFF8FF', \n      'margin-top': field.paddingTop ? `${field.paddingTop}px` : '0px',\n      'margin-bottom': field.paddingBottom ? `${field.paddingBottom}px` : '10px'\n    };\n    return styles;\n  }\n  getLineStyles(field: any): any {\n    const styles: any = {\n      'font-family': field.font || 'Helvetica Neue',\n      'font-weight': field.fontWeight || '400',\n      'font-size': field.fontSize || '14px',\n      'width': field.size ? `${(field.size / 12) * 100}%` : '100%',\n      'text-align': field.textAlign || 'left',\n      'border-radius': '5px',\n      'border-width': field.lineWidth ? `${field.lineWidth}px` : '1px',\n      'border-style': field.lineStyle?.toLowerCase() || 'solid',\n      'color': field.fontColor || '#000000',\n      //'border-color': field.color || '#EFF8FF', \n      'margin-top': field.paddingTop ? `${field.paddingTop}px` : '0px',\n      'margin-bottom': field.paddingBottom ? `${field.paddingBottom}px` : '10px'\n    };\n    return styles;\n  }\n  // SKS13MAR25 table popup conformation based element add\n  onClose() {\n    this.isSelectTablePopup = false\n    this.addTable = false\n    this.addElement(this.currentType)\n  }\n  // SKS13MAR25 column element add inside a table\n  addOnTable() {\n    this.addTable = true\n    this.isSelectTablePopup = false\n    const elements = [...this.formBuilderService.getElements()];\n\n    // Find the element and update its columns\n    const index = elements.findIndex(el => el.id === this.selectedElement.id);\n    const rowNum = this.formElements[index].columns ? this.formElements[index].columns?.length : 0\n    const unique_id = this.generateUiId();\n    const tableElement = {\n      label: `HEADER LABEL ${rowNum}`,\n      fieldName: `FIELD NAME${rowNum}`,\n      type: this.currentType,\n      id: unique_id\n    }\n    this.formBuilderService.addTableElement(tableElement, this.selectedFieldIndex);\n    this.formElements = this.formBuilderService.getElements();\n    // SKS19MAR25 fieldsmeta checking\n    this.formElements = this.formElements.map(ele => {\n      if (ele.type === 'Table') {\n        ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n          ? ele.fieldsMeta\n          : JSON.stringify(ele.fieldsMeta || []);\n      }\n      return ele;\n    });\n    // this.addTableData(unique_id, fieldName)\n  }\n  addTableData(fieldId, fieldName) {\n    // this.formBuilderService.addTablefieldData(tableElement);\n  }\n  columnSelected(event: any) {\n    // console.log(event)\n    // SKS19MAR25 table column update\n    this.formBuilderService.setSelectedTableElement(this.selectedFieldIndex, event);\n  }\n  removeColumn(event: any) {\n    // console.log(event)\n    this.formBuilderService.removeSelectedTableElement(this.selectedFieldIndex, event);\n  }\n\n  // SKS25MAR25 image add\n  async fileChangeEvent(index: any, event: any): Promise<void> {\n    const file = event.target.files[0];\n    if (file) {\n      try {\n        const imageData = await this.readFileAsDataURL(file);\n        this.formElements[index].imageData = imageData;\n        this.formElements[index].orgImageData = imageData;\n        // Initialize logo size if not already set\n        if (!this.formElements[index].imageSize) {\n          this.formElements[index].imageSize = { width: 150, height: 150 };\n        }\n  \n        await this.formBuilderService.elementUpdate(index, this.formElements[index]);\n      } catch (error) {\n        console.error(\"Error reading file:\", error);\n      }\n    }\n  }\n  \n  private readFileAsDataURL(file: File): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const reader = new FileReader();\n      reader.onload = () => resolve(reader.result as string);\n      reader.onerror = (error) => reject(error);\n      reader.readAsDataURL(file);\n    });\n  }\n  // SKS2APR25 disabled element\n  // isElementDisabled(elementType: string): boolean {\n  //   if(this.selectedElement){\n  //     const elements = this.elementDisabledArray[this.selectedElement.type]\n  //     if(elements){\n  //       return elements.includes(elementType);\n  //     }\n  //   }\n  //   return false;\n  // }\n}\n\n\n","<!-- AP 22JAN25 - form preview and All form elements -->\n<!-- AP 25FEB25 - All elements update -->\n<div class=\"center-frame\">\n  <!-- Form Builder Section All Elements -->\n  <div class=\"form-builder\">\n    <!-- Basic Elements Toggle -->\n    <div class=\"toggle-header\" (click)=\"toggleSection('basic')\">\n      <div class=\"head-elements\">Basic Elements</div>\n      <img [src]=\"sections.basic ? '../assets/icons/arrow-down.svg' : '../assets/icons/arrow-right.svg'\"\n        alt=\"Toggle Arrow\" class=\"arrow-icon\">\n    </div>\n\n    <div *ngIf=\"sections.basic\">\n      <ng-container *ngFor=\"let element of basicElements\">\n        <div class=\"element\" (click)=\"addElement(element.type)\">\n          <img src=\"../assets/icons/{{ element.img }}.svg\" class=\"element-icon\">\n          <div class=\"hover-label\">{{ element.label }}</div>\n          <div class=\"drag-dots\">\n            <div class=\"dot\" *ngFor=\"let dot of dots\"></div>\n          </div>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- Advanced Elements Toggle -->\n    <div class=\"toggle-header\" (click)=\"toggleSection('advanced')\">\n      <div class=\"head-elements\">Advanced Elements</div>\n      <img [src]=\"sections.advanced ? '../assets/icons/arrow-down.svg' : '../assets/icons/arrow-right.svg'\"\n        alt=\"Toggle Arrow\" class=\"arrow-icon\">\n    </div>\n\n    <div *ngIf=\"sections.advanced\">\n      <ng-container *ngFor=\"let element of advancedElements\">\n        <div class=\"element\" (click)=\"addElement(element.type)\">\n          <img src=\"../assets/icons/{{ element.img }}.svg\">\n          <div class=\"hover-label\">{{ element.label }}</div>\n          <div class=\"drag-dots\">\n            <div class=\"dot\" *ngFor=\"let dot of dots\"></div>\n          </div>\n        </div>\n      </ng-container>\n    </div>\n   <!-- AP-08APR25 Add Templates Component -->\n    <!-- <app-templates (templateSelected)=\"onTemplateSelected($event)\"></app-templates> -->\n\n    <!-- SKS10MAR25 footer version show -->\n    <div class=\"sticky-footer-version\">\n      {{version}}\n    </div>\n  </div>\n  <!-- AP-27MAR25 Remove CDK drag and drop replace draggable function  -->\n  <div class=\"form-preview\">\n    <!-- AP-10MAR25 Heading -->\n    <div class=\"field-container\"\n      style=\"width: 100%;background-color: #EFF8FF; border: 1px solid #E6F3FF;display: flex;justify-content: center;margin-bottom:10px\"\n      (click)=\"selectHeading('Header')\">\n      <div class=\"label-container\" style=\"padding: 10px;\">\n        <div *ngIf=\"book?.records\">\n          <div *ngIf=\"book.records[0].title == ''\" style=\"color:#3f4a525c\">Heading</div>\n          <div *ngIf=\"book.records[0].title !== ''\">{{book.records[0].title}}</div>\n        </div>\n      </div>    \n    </div>\n  <!-- <div class=\"preview-header\">\n    <button \n    style=\"background: none; border: none; cursor: pointer; padding: 4px;\" title=\"Preview\">\n    <span class=\"material-icons\" style=\"font-size: 18px; color: #EFF8FF;\">\n      visibility\n    </span>\n  </button>\n  </div> -->\n\n    <ng-container *ngFor=\"let field of formElements; let i = index\" getProperties().elementProps>\n\n      <!-- TextBox -->\n      <div *ngIf=\"field.type === 'Text'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isOptional\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"text\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter text'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : '' \" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-19MAR25 Line Element -->\n      <div *ngIf=\"field.type === 'Line'\" class=\"line-field\" (click)=\"selectElement(i)\"\n        [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\" (dragstart)=\"onDragStart($event, i)\"\n        (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"line-element\">\n          <div></div>\n          <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n        </div>\n        <hr class=\"custom-line\" style=\"display: inline-flex\" [ngStyle]=\"getLineStyles(field)\" />\n      </div>\n\n      <!--SKS25MAR25 Image Upload Element -->\n      <div *ngIf=\"field.type === 'Image'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\" (dragstart)=\"onDragStart($event, i)\"\n        (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\" [ngStyle]=\"getFontStyles(field)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Upload Image' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div>\n              <div class=\"logo-container\">\n                <!-- Logo preview area -->\n                <div class=\"logo-preview\" *ngIf=\"field.imageData\">\n                  <img [src]=\"field.imageData\" />\n                </div>\n\n                <!-- Upload button -->\n                <div *ngIf=\"!field.imageData\" class=\"logo-upload-placeholder\">\n                  <label for=\"logo-upload-{{i}}\" class=\"logo-upload-label\">\n                    <img src=\"../assets/icons/Image.svg\" alt=\"Upload\" />\n                    <span>Upload Image</span>\n                  </label>\n                  <input type=\"file\" id=\"logo-upload-{{i}}\" accept=\"image/*\" (change)=\"fileChangeEvent(i, $event)\"\n                    style=\"display: none;\" />\n                </div>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Space Element -->\n      <div *ngIf=\"field.type === 'Space'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\" style=\"height:93px\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <label [class.required]=\"field.isRequired\"></label>\n              <div class=\"top-right\" style=\"margin: -11px -11px 0 0;\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Boolean Element -->\n      <div *ngIf=\"field.type === 'Boolean'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"label-container\">\n            <div>\n              <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{ field.questionText\n                ? field.questionText : 'Boolean'}}</label>\n            </div>\n            <div class=\"top-right\">\n              <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n              <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n            </div>\n          </div>\n          <input type=\"checkbox\" [checked]=\"field.boolean\" (change)=\"toggleBoolean(field)\"\n            [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n        </div>\n      </div>\n\n      <!-- Calendar -->\n      <div *ngIf=\"field.type === 'Calendar'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n\n            </div>\n            <input type=\"date\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP -12MAR25 Date -->\n      <div *ngIf=\"field.type === 'Date'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n\n            </div>\n            <input type=\"date\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-21MAR25 Add Time element -->\n      <!-- Time Field -->\n      <div *ngIf=\"field.type === 'Time'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <label [class.required]=\"field.isRequired\">{{ field.questionText ? field.questionText : 'Time' }}</label>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"time\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-28MAR25 DateTime -->\n      <div *ngIf=\"field.type === 'DateTime'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date & Time'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"datetime-local\" class=\"custom-input\" [readonly]=\"field.isReadOnly\"\n              [class.hidden]=\"field.isHidden\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- Email -->\n      <div *ngIf=\"field.type === 'Email'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\"> {{ field.questionText ? field.questionText : 'Label' }}\n                </label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"email\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter email'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- Numbers -->\n      <div *ngIf=\"field.type === 'Number'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"number\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter number'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- TextArea -->\n      <div *ngIf=\"field.type === 'TextArea'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Enter your text'}}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <textarea class=\"custom-textarea\" [placeholder]=\"field.question || 'Enter detailed text here...'\"\n              [style.height.px]=\"field.size || 100\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\"></textarea>\n          </div>\n        </div>\n      </div>\n\n      <!-- RichText -->\n      <div *ngIf=\"field.type === 'RichTextArea'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Enter your text'}}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <textarea class=\"custom-textarea\" [placeholder]=\"field.question || 'Enter detailed text here...'\"\n              [style.height.px]=\"field.size || 100\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\"></textarea>\n          </div>\n        </div>\n      </div>\n\n      <!-- Label -->\n      <div *ngIf=\"field.type === 'Label'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Book -->\n      <div *ngIf=\"field.type === 'Book'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <lib-booklet [bookletJSON]=\"field.qbReferenceQuestions\"></lib-booklet>\n          </div>\n        </div>\n      </div>\n\n      <!-- File -->\n      <div *ngIf=\"field.type === 'File'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Upload File'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"file\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- CheckBox -->\n      <div *ngIf=\"field.type === 'Checkbox'\" class=\"checkbox-field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">\n                  {{ field.questionText ? field.questionText : 'Label' }}\n                </label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n\n            <div class=\"checkbox-options-container\">\n              <div *ngFor=\"let option of field.options\" class=\"checkbox-option\">\n                <input type=\"checkbox\" [id]=\"option.value + i\" [name]=\"field.id\"\n                  [value]=\"option.value || field.defaultValue\" class=\"checkbox-input\" [disabled]=\"field.isReadOnly\"\n                  [class.hidden]=\"field.isHidden\">\n                <label [for]=\"option.value + i\" class=\"checkbox-label\">{{ option.value }}</label>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Radio -->\n      <div *ngIf=\"field.type === 'Radio'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div class=\"radio-options-container\">\n              <div *ngFor=\"let option of field.options; let j = index\" class=\"radio-option\">\n                <input type=\"radio\" [id]=\"'radio-' + field.id + '-' + j\" [name]=\"'radio-group-' + field.id\"\n                  [value]=\"option.value || field.defaultValue\" [(ngModel)]=\"field.selectedValue\" class=\"radio-input\"\n                  [disabled]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\">\n                <label [for]=\"'radio-' + field.id + '-' + j\" class=\"radio-label\"> {{ option.value }}</label>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n      <!-- Dropdown -->\n      <div *ngIf=\"field.type === 'Dropdown'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <select id=\"options\" class=\"dropdown\" [disabled]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\">\n              <option *ngFor=\"let option of field.options\" [value]=\"option.value || field.defaultValue\"> {{ option.value\n                }} </option>\n            </select>\n          </div>\n        </div>\n      </div>\n\n      <!--  Table  -->\n      <!-- AP-06MAR25 -->\n      <div *ngIf=\"field.type === 'Table'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\" style=\"overflow: hidden;\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div class=\"nxt-table-container\">\n              <nxt-datatable  isButtons [question]=\"field\" from=\"formBuilder\" [apiMeta]=\"field.subText\"\n                [tableConfig]=\"field.tableConfig\" tableId=\"\" direction=\"ltr\" tableWidth=\"auto\" isEditable=true\n                (columnSelected)=columnSelected($event) (removeColumn)=removeColumn($event)>\n              </nxt-datatable>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- List -->\n      <!-- AP-06MAR25 - List data show-->\n      <div *ngIf=\"field.type === 'List'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"text\" class=\"custom-input\" placeholder=\"Search...\" [readonly]=\"field.isReadOnly\"\n              [class.hidden]=\"field.isHidden\" [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n    </ng-container>\n  </div>\n</div>\n<!-- SKS13MAR25 popup conformation box -->\n<div class=\"dialog-overlay\" *ngIf=\"isSelectTablePopup\">\n  <div class=\"dialog-box\">\n    <button class=\"close-btn-fb\" (click)=\"onClose()\">✕</button>\n    <p>These element want to add a table</p>\n    <div class=\"button-container-fb\">\n      <button class=\"yes-btn-fb\" (click)=\"addOnTable()\">Yes</button>\n      <button class=\"no-btn-fb\" (click)=\"onClose()\">No</button>\n    </div>\n  </div>\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element.component.js","sourceRoot":"","sources":["../../../../../../../projects/nxt-app/src/lib/pages/builder/element/element.component.ts","../../../../../../../projects/nxt-app/src/lib/pages/builder/element/element.component.html"],"names":[],"mappings":"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","sourcesContent":["// AP 22JAN25 - form preview and All form elements\nimport { Component, EventEmitter, Input, Output, SimpleChanges } from '@angular/core';\nimport { FormBuilderService } from '../../../services/form-builder.service'\nimport { VERSION } from '../../../../environments/version';\n\n@Component({\n  selector: 'app-element',\n  templateUrl: './element.component.html',\n  styleUrls: ['./element.component.css'],\n})\n\nexport class ElementComponent {\n\n  //@Output() elementButtonClicked = new EventEmitter<string>();\n  @Input() bookletJSON: any;\n  @Input() bookletId: any;\n  @Output() templateMode = new EventEmitter<boolean>();\n  field: any;\n  formElements: any[] = [];\n  elements: any[] = [];\n  bookId: string;\n  sections = {\n    basic: true,    // Basic Elements open by default\n    advanced: true // Advanced Elements closed by default\n  };\n  basicElements: any[] = [];\n  advancedElements: any[] = [];\n  //elementDisabledArray: any;\n  version = VERSION.version; //SKS10MAR25 get version from environment/version.ts \n  book: any;\n  selectedElement: any = null;\n  isSelectTablePopup: boolean = false;\n  currentType: string;\n  addTable: boolean = true;\n  dots = Array(6);\n  draggedIndex: number | null = null;\n  templateSelected = false;\n\n  //subscription: any;\n  constructor(private formBuilderService: FormBuilderService) {\n  }\n//  AP-06MAR25 New Design Change Elements Basic , Advanced\n// AP-06MAR25 Add RichText Area\n// AP-12MAR25 Add Date\nngOnInit() {\n  this.basicElements = [\n  \n  { \"type\": \"Text\", \"img\": \"Text\", \"label\": \"Text\" },\n  { \"type\": \"Number\", \"img\": \"Number\", \"label\": \"Number\" },\n  { \"type\": \"Label\", \"img\": \"Label\", \"label\": \"Label\" },\n  { \"type\": \"Email\", \"img\": \"Email\", \"label\": \"Email\" },\n  { \"type\": \"Date\", \"img\": \"Date\", \"label\": \"Date\" },\n  { \"type\": \"Time\", \"img\": \"Time\", \"label\": \"Time\" },\n  { \"type\": \"DateTime\", \"img\": \"DateTime\", \"label\": \"DateTime\" },\n  { \"type\": \"Calendar\", \"img\": \"Calendar\", \"label\": \"Calendar\" },\n  { \"type\": \"File\", \"img\": \"File\", \"label\": \"Files\" },\n  { \"type\": \"Image\", \"img\": \"Image\", \"label\": \"Image\" },\n  { \"type\": \"Checkbox\", \"img\": \"CheckBox\", \"label\": \"Checkbox\" },\n  { \"type\": \"Radio\", \"img\": \"Radio\", \"label\": \"Radio\" },\n  { \"type\": \"Dropdown\", \"img\": \"Drop\", \"label\": \"Dropdown\" },\n  { \"type\": \"TextArea\", \"img\": \"TextArea\", \"label\": \"Text Area\" },\n  { \"type\": \"RichTextArea\", \"img\": \"RichText\", \"label\": \"Rich Text\" }, \n  \n    ];\n\n    this.advancedElements = [\n  { \"type\": \"Line\", \"img\": \"line\", \"label\": \"Line\" },\n  { \"type\": \"Space\", \"img\": \"space\", \"label\": \"Space\" },  \n  { \"type\": \"Boolean\", \"img\": \"Boolean\", \"label\": \"Boolean\" },\n  { \"type\": \"Book\", \"img\": \"Search\", \"label\": \"Book\" },\n  { \"type\": \"List\", \"img\": \"Search\", \"label\": \"List\" },\n  { \"type\": \"Table\", \"img\": \"Table\", \"label\": \"Table\" },\n  { \"type\": \"Button\", \"img\": \"Button\", \"label\": \"Button\" }\n    ];\n    // this.elementDisabledArray = {\n    //   Table: [\n    //     'Book', 'Calendar',\"Boolean\", 'List', 'Table', 'Checkbox', 'Radio', \n    //     'Dropdown', 'TextArea', 'RichTextArea', 'Number', 'Label', 'Image', \n    //     'Email', 'Date', 'Time', 'DateTime', 'Line', 'Space'\n    //   ]\n    // };\n    \n    this.formBuilderService.formElements$.subscribe(elements => {\n      setTimeout(() => {\n        this.formElements = elements.map(field => ({ ...field }));\n      }, 0);\n    });\n    if (this.bookletJSON && (this.bookletJSON !== '')) {\n      this.initializeForm();\n    } else {\n      this.formBuilderService.newBook()\n    }\n    // AP-12MAR25 - Added to handle bookletId\n    if (this.bookletId) {\n      localStorage.setItem('unique_id', this.bookletId);\n      \n    }\n    this.book = this.formBuilderService.getBook();\n    this.formBuilderService.selectedElement$.subscribe(index => {\n      const elements = this.formBuilderService.getElements();\n      if (index >= 0) {\n        this.selectedElement = elements[index];\n      }\n      // SKS19MAR25 for fieldMeta checking\n      if (this.selectedElement?.type === 'Table') {\n        this.selectedElement['fieldsMeta'] = typeof this.selectedElement.fieldsMeta === 'string' ? this.selectedElement.fieldsMeta : JSON.stringify(this.selectedElement['fieldsMeta'] || []);\n      }\n      // this.formElements = [...elements]\n    });\n    this.formBuilderService.addElementWithId();\n  }\n\n  // Add these methods\n  toggleSection(section: 'basic' | 'advanced') {\n    this.sections[section] = !this.sections[section];\n  }\n\n  isSectionOpen(section: string): boolean {\n    return this.sections[section];\n  }\n\n  // AP - 26FEB25 - Added ngOnChanges to handle changes in bookletJSON\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['bookletJSON'] && changes['bookletJSON'].currentValue) {\n      if (this.bookletJSON && this.bookletJSON !== '') {\n        // AP-28MAY25 - Check and transform `action` if it's in Existing format\n        if (\n          this.bookletJSON.questionbook &&\n          this.bookletJSON.questionbook.action &&\n          typeof this.bookletJSON.questionbook.action === 'string'\n        ) {\n          try {\n            const parsedActions = JSON.parse(this.bookletJSON.questionbook.action);\n  \n            // AP-28MAY25 Assign specific positionPercent based on action name\n            const newActions = parsedActions.map((item: any, index: number) => {\n              const positionPercent = item.name === 'Cancel' ? 3 :\n                                      item.name === 'Save' ? 14 : (10 + index * 10);\n  \n              return {\n                ...item,\n                positionPercent: positionPercent,\n                width: 100,\n                textColor: \"#ffffff\",\n                borderRadius: 6,\n                id: index + 1\n              };\n            });\n          // AP-28MAY25 Replace the old action string with the newly formatted array\n            this.bookletJSON.questionbook.action = newActions;\n          } catch (e) {\n            console.error(\"Error parsing action JSON string:\", e);\n          }\n        }\n  \n        this.initializeForm();\n      } else {\n        this.formBuilderService.newBook();\n      }\n    }\n  }\n  // AP-08APR25 Template is selected, update form elements and emit template mode\n  onTemplateSelected(event: { selectedTemplate: any; elements: any[] }) {\n    this.formBuilderService.clearElements();\n    event.elements.forEach(el => this.formBuilderService.addElement(el));\n\n    // Emit template mode to parent\n   this.templateMode.emit(true);\n  }\n\n  private initializeForm() {\n    if (!this.bookletJSON || !this.bookletJSON.bookQuestionsMap) {\n      console.warn(\"Invalid bookletJSON structure\");\n      return;\n    }\n    this.formElements = []\n    this.formBuilderService.clearElements();\n    this.formBuilderService.intializeBook(this.bookletJSON);\n  \n    const bookQuestionsMap = this.bookletJSON.bookQuestionsMap;\n    const bookQuestionsMapKeys = Object.keys(bookQuestionsMap);\n  \n    if (bookQuestionsMapKeys.length === 0) return;\n  \n    for (const key of bookQuestionsMapKeys) {\n      const subQuestions = bookQuestionsMap[key]?.subQuestions;\n  \n      if (Array.isArray(subQuestions)) {\n        subQuestions.forEach((subQuestion) => {\n           // AP-04APR24 If subQuestion.style exists as a string and is empty, replace it with a default style object\n          if (typeof subQuestion.style === \"string\" && subQuestion.style.trim() === \"\") {\n            subQuestion.style = {\n              \"labelClass\": null,\n              \"labelStyle\": null,\n              \"labelValueStyle\": null,\n              \"inputClass\": null,\n              \"inputStyle\": null,\n              \"showLabel\": true,\n              \"bookStyle\": null,\n              \"direction\": \"ltr\",\n              \"questionStyle\": null\n            };\n          }\n        });\n      }\n    }\n    this.formElements = this.formBuilderService.getElements();\n  }\n\n  // Add this method to handle element selection\n  selectElement(index: number) {\n    this.selectedFieldIndex = index; // element is selected\n    this.formBuilderService.setSelectedElement(index);\n    this.book = this.formBuilderService.getBook();\n    //const element = this.formElements[index];\n    // this.elementButtonClicked.emit(element.type);  \n  }\n  //selectedIndex: number | null = null;\n  selectedFieldIndex: number | null = null; // element is cleared\n\n  selectHeading(event: any) {\n    this.formBuilderService.selectHeading(event); //AP-10MAR25 Updates the selected heading in the service  \n    this.book = this.formBuilderService.getBook(); //AP-10MAR25 Retrieves the updated book/form data \n  }\n// AP-17APR25 generateUiId \n  generateUiId() {\n    return this.formBuilderService.addElementWithId();  \n  }  \n\n  addElement(type: string): void {\n    const unique_id = this.generateUiId();\n    this.currentType = type\n    if (this.selectedElement?.type === 'Table' && this.addTable) {\n      this.isSelectTablePopup = true\n    } else {\n      const newElement = {\n        action: null,\n        id: unique_id,\n        uid: unique_id,\n        type,\n        name: null,\n        questionText: null,\n        question: null,\n        helpText: null,\n        errorMessage: null,\n        isReadOnly: false,\n        isHidden: false,\n        required: false,\n        referenceField: null,\n        additionalRichContent: null,\n        groupName: null,\n        isDateBackward: false,\n        title: null,\n        subTitle: null,\n        size: 12,\n        isDateForward: false,\n        isOptional: false,\n        isTitle: false,\n        nextQuestion: null,\n        allowedFileExtensions: null,\n        questionNumber: this.formBuilderService.getElements().length + 1,\n        order: this.formElements.length + 1,\n        questionBookId: this.bookletId,\n        parentQuestion: null,\n        fieldsMeta: [],\n        recordTypeName: null,\n        recordTypeId: null,\n        trackingId: null,\n        dateText: null,\n        timeText: null,\n        recordId: null,\n        qbReference: null,\n        qbReferenceQuestions: null,\n        questionBookSubTitle: null,\n        style: {\n          labelClass: null,\n          labelStyle: null,\n          labelValueStyle: null,\n          inputClass: null,\n          inputStyle: null,\n          showLabel: true,\n          bookStyle: null,\n          direction: 'ltr',\n          questionStyle: null,\n        },\n        subText: this.getDefaultSubText(), \n        imageData: null,\n        boolean: false,\n        options: type === 'Dropdown' || type === 'Radio' || type === 'Checkbox' ? [] : null,\n        imageSize:  type === 'Image' ? { width: 150, height: 150 } : null,\n        tableConfig: type === 'Table' ? {\n          isNosIndicator: true,\n          addInlineRecord: true,\n          isPagination: true,\n          actionButton: true,\n          isDeleteRow: true,\n          isEditRow: true,\n          searchBar: true,\n          isButtons: true,\n          itemsPerPage: 10,\n        } : null,\n      };\n      this.formBuilderService.addElement(newElement);\n      this.formElements = this.formBuilderService.getElements();\n      // SKS19MAR25 fieldsmeta check\n      this.formElements = this.formElements.map(ele => {\n        if (ele.type === 'Table') {\n          ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n            ? ele.fieldsMeta\n            : JSON.stringify(ele.fieldsMeta || []);\n        }\n        return ele;\n      });\n      this.addTable = true\n    }\n  }\n  // AP-07MAY25 - Added to handle default subText\n  getDefaultSubText() {\n    const defaultData = {\n      endpoint: null,\n      variable: null,\n      field: null,\n      defaultField: null,\n      sourceQuestionId: null,\n      valueField: null,\n      labelField: null,\n      isDependentField: false,\n      dependentValue: null,\n      queryField: null,\n      queryValue: null,\n      queryValueReference: null,\n      uniqueKey: null,\n      \n    };\n  \n    const isEmpty = Object.values(defaultData).every(\n      val => val === null || val === false\n    );\n  \n    return isEmpty ? null : defaultData;\n  }  \n  // Remove an element by index\n  removeElement(field: any, index: number): void {\n    this.formBuilderService.removeElementComponent(field.id);\n    this.formElements = this.formBuilderService.getElements();\n    // SKS19MAR25 fieldsmeta check\n    this.formElements = this.formElements.map(ele => {\n      if (ele.type === 'Table') {\n        ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n          ? ele.fieldsMeta\n          : JSON.stringify(ele.fieldsMeta || []);\n      }\n      return ele;\n    });\n  }\n\n  onDragStart(event: DragEvent, index: number) {\n    this.draggedIndex = index;\n    event.dataTransfer?.setData('text/plain', index.toString());\n  }\n\n  // Allow dropping by preventing default\n  onDragOver(event: DragEvent, index: number) {\n    event.preventDefault();\n  }\n\n  // Handle drop event\n  onDrop(event: DragEvent, dropIndex: number) {\n    event.preventDefault();\n\n    if (this.draggedIndex === null || this.draggedIndex === dropIndex) return;\n\n    const draggedItem = this.formElements[this.draggedIndex];\n\n    // Remove dragged item from old position and insert it in new position\n    this.formElements.splice(this.draggedIndex, 1);\n    this.formElements.splice(dropIndex, 0, draggedItem);\n\n  //AP-28MAR25 Update questionNumber dynamically based on new order\n  this.formElements.forEach((element, index) => {\n    element.questionNumber = index + 1;\n  });\n\n    // Reset dragged index\n    this.draggedIndex = null;\n\n    // Notify service about the update\n    this.formBuilderService.updateElementsOrder(this.formElements);\n  }\n  \n  toggleBoolean(field: any): void {\n    field.boolean = !field.boolean;\n  }\n  getFontStyles(field: any): any {\n    const styles: any = {\n      'font-family': field.font || 'Helvetica Neue',\n      'font-weight': field.fontWeight || '400',\n      'font-size': field.fontSize || '14px',\n      'width': field.size ? `${(field.size / 12) * 100}%` : '100%',\n      'text-align': field.textAlign || 'left',\n      'border-radius': '5px',\n      'border-width': field.lineWidth ? `${field.lineWidth}px` : '1px',\n      // 'border-style': field.lineStyle?.toLowerCase() || 'solid',\n      'color': field.fontColor || '#000000',\n      // 'border-color': field.color || '#EFF8FF', \n      'margin-top': field.paddingTop ? `${field.paddingTop}px` : '0px',\n      'margin-bottom': field.paddingBottom ? `${field.paddingBottom}px` : '10px'\n    };\n    return styles;\n  }\n  getLineStyles(field: any): any {\n    const styles: any = {\n      'font-family': field.font || 'Helvetica Neue',\n      'font-weight': field.fontWeight || '400',\n      'font-size': field.fontSize || '14px',\n      'width': field.size ? `${(field.size / 12) * 100}%` : '100%',\n      'text-align': field.textAlign || 'left',\n      'border-radius': '5px',\n      'border-width': field.lineWidth ? `${field.lineWidth}px` : '1px',\n      'border-style': field.lineStyle?.toLowerCase() || 'solid',\n      'color': field.fontColor || '#000000',\n      //'border-color': field.color || '#EFF8FF', \n      'margin-top': field.paddingTop ? `${field.paddingTop}px` : '0px',\n      'margin-bottom': field.paddingBottom ? `${field.paddingBottom}px` : '10px'\n    };\n    return styles;\n  }\n  // SKS13MAR25 table popup conformation based element add\n  onClose() {\n    this.isSelectTablePopup = false\n    this.addTable = false\n    this.addElement(this.currentType)\n  }\n  // SKS13MAR25 column element add inside a table\n  addOnTable() {\n    this.addTable = true\n    this.isSelectTablePopup = false\n    const elements = [...this.formBuilderService.getElements()];\n\n    // Find the element and update its columns\n    const index = elements.findIndex(el => el.id === this.selectedElement.id);\n    const rowNum = this.formElements[index].columns ? this.formElements[index].columns?.length : 0\n    const unique_id = this.generateUiId();\n    const tableElement = {\n      label: `HEADER LABEL ${rowNum}`,\n      fieldName: `FIELD NAME${rowNum}`,\n      type: this.currentType,\n      id: unique_id\n    }\n    this.formBuilderService.addTableElement(tableElement, this.selectedFieldIndex);\n    this.formElements = this.formBuilderService.getElements();\n    // SKS19MAR25 fieldsmeta checking\n    this.formElements = this.formElements.map(ele => {\n      if (ele.type === 'Table') {\n        ele.fieldsMeta = typeof ele.fieldsMeta === 'string'\n          ? ele.fieldsMeta\n          : JSON.stringify(ele.fieldsMeta || []);\n      }\n      return ele;\n    });\n    // this.addTableData(unique_id, fieldName)\n  }\n  addTableData(fieldId, fieldName) {\n    // this.formBuilderService.addTablefieldData(tableElement);\n  }\n  columnSelected(event: any) {\n    // console.log(event)\n    // SKS19MAR25 table column update\n    this.formBuilderService.setSelectedTableElement(this.selectedFieldIndex, event);\n  }\n  removeColumn(event: any) {\n    // console.log(event)\n    this.formBuilderService.removeSelectedTableElement(this.selectedFieldIndex, event);\n  }\n\n  // SKS25MAR25 image add\n  async fileChangeEvent(index: any, event: any): Promise<void> {\n    const file = event.target.files[0];\n    if (file) {\n      try {\n        const imageData = await this.readFileAsDataURL(file);\n        this.formElements[index].imageData = imageData;\n        this.formElements[index].orgImageData = imageData;\n        // Initialize logo size if not already set\n        if (!this.formElements[index].imageSize) {\n          this.formElements[index].imageSize = { width: 150, height: 150 };\n        }\n  \n        await this.formBuilderService.elementUpdate(index, this.formElements[index]);\n      } catch (error) {\n        console.error(\"Error reading file:\", error);\n      }\n    }\n  }\n  \n  private readFileAsDataURL(file: File): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const reader = new FileReader();\n      reader.onload = () => resolve(reader.result as string);\n      reader.onerror = (error) => reject(error);\n      reader.readAsDataURL(file);\n    });\n  }\n  // SKS2APR25 disabled element\n  // isElementDisabled(elementType: string): boolean {\n  //   if(this.selectedElement){\n  //     const elements = this.elementDisabledArray[this.selectedElement.type]\n  //     if(elements){\n  //       return elements.includes(elementType);\n  //     }\n  //   }\n  //   return false;\n  // }\n}\n\n\n","<!-- AP 22JAN25 - form preview and All form elements -->\n<!-- AP 25FEB25 - All elements update -->\n<div class=\"center-frame\">\n  <!-- Form Builder Section All Elements -->\n  <div class=\"form-builder\">\n    <!-- Basic Elements Toggle -->\n    <div class=\"toggle-header\" (click)=\"toggleSection('basic')\">\n      <div class=\"head-elements\">Basic Elements</div>\n      <img [src]=\"sections.basic ? '../assets/icons/arrow-down.svg' : '../assets/icons/arrow-right.svg'\"\n        alt=\"Toggle Arrow\" class=\"arrow-icon\">\n    </div>\n\n    <div *ngIf=\"sections.basic\">\n      <ng-container *ngFor=\"let element of basicElements\">\n        <div class=\"element\" (click)=\"addElement(element.type)\">\n          <img src=\"../assets/icons/{{ element.img }}.svg\" class=\"element-icon\">\n          <div class=\"hover-label\">{{ element.label }}</div>\n          <div class=\"drag-dots\">\n            <div class=\"dot\" *ngFor=\"let dot of dots\"></div>\n          </div>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- Advanced Elements Toggle -->\n    <div class=\"toggle-header\" (click)=\"toggleSection('advanced')\">\n      <div class=\"head-elements\">Advanced Elements</div>\n      <img [src]=\"sections.advanced ? '../assets/icons/arrow-down.svg' : '../assets/icons/arrow-right.svg'\"\n        alt=\"Toggle Arrow\" class=\"arrow-icon\">\n    </div>\n\n    <div *ngIf=\"sections.advanced\">\n      <ng-container *ngFor=\"let element of advancedElements\">\n        <div class=\"element\" (click)=\"addElement(element.type)\">\n          <img src=\"../assets/icons/{{ element.img }}.svg\">\n          <div class=\"hover-label\">{{ element.label }}</div>\n          <div class=\"drag-dots\">\n            <div class=\"dot\" *ngFor=\"let dot of dots\"></div>\n          </div>\n        </div>\n      </ng-container>\n    </div>\n   <!-- AP-08APR25 Add Templates Component -->\n    <!-- <app-templates (templateSelected)=\"onTemplateSelected($event)\"></app-templates> -->\n\n    <!-- SKS10MAR25 footer version show -->\n    <div class=\"sticky-footer-version\">\n      {{version}}\n    </div>\n  </div>\n  <!-- AP-27MAR25 Remove CDK drag and drop replace draggable function  -->\n  <div class=\"form-preview\">\n    <!-- AP-10MAR25 Heading -->\n    <div class=\"field-container\"\n      style=\"width: 100%;background-color: #EFF8FF; border: 1px solid #E6F3FF;display: flex;justify-content: center;margin-bottom:10px\"\n      (click)=\"selectHeading('Header')\">\n      <div class=\"label-container\" style=\"padding: 10px;\">\n        <div *ngIf=\"book?.records\">\n          <div *ngIf=\"book.records[0].title == ''\" style=\"color:#3f4a525c\">Heading</div>\n          <div *ngIf=\"book.records[0].title !== ''\">{{book.records[0].title}}</div>\n        </div>\n      </div>    \n    </div>\n  <!-- <div class=\"preview-header\">\n    <button \n    style=\"background: none; border: none; cursor: pointer; padding: 4px;\" title=\"Preview\">\n    <span class=\"material-icons\" style=\"font-size: 18px; color: #EFF8FF;\">\n      visibility\n    </span>\n  </button>\n  </div> -->\n\n    <ng-container *ngFor=\"let field of formElements; let i = index\" getProperties().elementProps>\n\n      <!-- TextBox -->\n      <div *ngIf=\"field.type === 'Text'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isOptional\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"text\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter text'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : '' \" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-19MAR25 Line Element -->\n      <div *ngIf=\"field.type === 'Line'\" class=\"line-field\" (click)=\"selectElement(i)\"\n        [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\" (dragstart)=\"onDragStart($event, i)\"\n        (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"line-element\">\n          <div></div>\n          <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n        </div>\n        <hr class=\"custom-line\" style=\"display: inline-flex\" [ngStyle]=\"getLineStyles(field)\" />\n      </div>\n\n      <!--SKS25MAR25 Image Upload Element -->\n      <div *ngIf=\"field.type === 'Image'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\" (dragstart)=\"onDragStart($event, i)\"\n        (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\" [ngStyle]=\"getFontStyles(field)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Upload Image' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div>\n              <div class=\"logo-container\">\n                <!-- Logo preview area -->\n                <div class=\"logo-preview\" *ngIf=\"field.imageData\">\n                  <img [src]=\"field.imageData\" />\n                </div>\n\n                <!-- Upload button -->\n                <div *ngIf=\"!field.imageData\" class=\"logo-upload-placeholder\">\n                  <label for=\"logo-upload-{{i}}\" class=\"logo-upload-label\">\n                    <img src=\"../assets/icons/Image.svg\" alt=\"Upload\" />\n                    <span>Upload Image</span>\n                  </label>\n                  <input type=\"file\" id=\"logo-upload-{{i}}\" accept=\"image/*\" (change)=\"fileChangeEvent(i, $event)\"\n                    style=\"display: none;\" />\n                </div>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Space Element -->\n      <div *ngIf=\"field.type === 'Space'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\" style=\"height:93px\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <label [class.required]=\"field.isRequired\"></label>\n              <div class=\"top-right\" style=\"margin: -11px -11px 0 0;\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Boolean Element -->\n      <div *ngIf=\"field.type === 'Boolean'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"label-container\">\n            <div>\n              <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{ field.questionText\n                ? field.questionText : 'Boolean'}}</label>\n            </div>\n            <div class=\"top-right\">\n              <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n              <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n            </div>\n          </div>\n          <input type=\"checkbox\" [checked]=\"field.boolean\" (change)=\"toggleBoolean(field)\"\n            [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n        </div>\n      </div>\n\n      <!-- Calendar -->\n      <div *ngIf=\"field.type === 'Calendar'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n\n            </div>\n            <input type=\"date\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP -12MAR25 Date -->\n      <div *ngIf=\"field.type === 'Date'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n\n            </div>\n            <input type=\"date\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-21MAR25 Add Time element -->\n      <!-- Time Field -->\n      <div *ngIf=\"field.type === 'Time'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <label [class.required]=\"field.isRequired\">{{ field.questionText ? field.questionText : 'Time' }}</label>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"time\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- AP-28MAR25 DateTime -->\n      <div *ngIf=\"field.type === 'DateTime'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Select Date & Time'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"datetime-local\" class=\"custom-input\" [readonly]=\"field.isReadOnly\"\n              [class.hidden]=\"field.isHidden\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- Email -->\n      <div *ngIf=\"field.type === 'Email'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\"> {{ field.questionText ? field.questionText : 'Label' }}\n                </label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"email\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter email'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- Numbers -->\n      <div *ngIf=\"field.type === 'Number'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"number\" class=\"custom-input\" [placeholder]=\"field.question || 'Enter number'\"\n              [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- TextArea -->\n      <div *ngIf=\"field.type === 'TextArea'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Enter your text'}}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <textarea class=\"custom-textarea\" [placeholder]=\"field.question || 'Enter detailed text here...'\"\n              [style.height.px]=\"field.size || 100\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\"></textarea>\n          </div>\n        </div>\n      </div>\n\n      <!-- RichText -->\n      <div *ngIf=\"field.type === 'RichTextArea'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Enter your text'}}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <textarea class=\"custom-textarea\" [placeholder]=\"field.question || 'Enter detailed text here...'\"\n              [style.height.px]=\"field.size || 100\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\"\n              [value]=\"field.defaultValue ? field.defaultValue : ''\"></textarea>\n          </div>\n        </div>\n      </div>\n\n      <!-- Label -->\n      <div *ngIf=\"field.type === 'Label'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Book -->\n      <div *ngIf=\"field.type === 'Book'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <lib-booklet [bookletJSON]=\"field.qbReferenceQuestions\"></lib-booklet>\n          </div>\n        </div>\n      </div>\n\n      <!-- File -->\n      <div *ngIf=\"field.type === 'File'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Upload File'\n                  }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"file\" class=\"custom-input\" [readonly]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\" />\n          </div>\n        </div>\n      </div>\n\n      <!-- CheckBox -->\n      <div *ngIf=\"field.type === 'Checkbox'\" class=\"checkbox-field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">\n                  {{ field.questionText ? field.questionText : 'Label' }}\n                </label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n\n            <div class=\"checkbox-options-container\">\n              <div *ngFor=\"let option of field.options\" class=\"checkbox-option\">\n                <input type=\"checkbox\" [id]=\"option.value + i\" [name]=\"field.id\"\n                  [value]=\"option.value || field.defaultValue\" class=\"checkbox-input\" [disabled]=\"field.isReadOnly\"\n                  [class.hidden]=\"field.isHidden\">\n                <label [for]=\"option.value + i\" class=\"checkbox-label\">{{ option.value }}</label>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Radio -->\n      <div *ngIf=\"field.type === 'Radio'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div class=\"radio-options-container\">\n              <div *ngFor=\"let option of field.options; let j = index\" class=\"radio-option\">\n                <input type=\"radio\" [id]=\"'radio-' + field.id + '-' + j\" [name]=\"'radio-group-' + field.id\"\n                  [value]=\"option.value || field.defaultValue\" [(ngModel)]=\"field.selectedValue\" class=\"radio-input\"\n                  [disabled]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\">\n                <label [for]=\"'radio-' + field.id + '-' + j\" class=\"radio-label\"> {{ option.value }}</label>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n      <!-- Dropdown -->\n      <div *ngIf=\"field.type === 'Dropdown'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <select id=\"options\" class=\"dropdown\" [disabled]=\"field.isReadOnly\" [class.hidden]=\"field.isHidden\">\n              <option *ngFor=\"let option of field.options\" [value]=\"option.value || field.defaultValue\"> {{ option.value\n                }} </option>\n            </select>\n          </div>\n        </div>\n      </div>\n\n      <!--  Table  -->\n      <!-- AP-06MAR25 -->\n      <div *ngIf=\"field.type === 'Table'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\" style=\"overflow: hidden;\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <div class=\"nxt-table-container\">\n              <nxt-datatable  isButtons [question]=\"field\" from=\"formBuilder\" [apiMeta]=\"field.subText\"\n                [tableConfig]=\"field.tableConfig\" tableId=\"\" direction=\"ltr\" tableWidth=\"auto\" isEditable=true\n                (columnSelected)=columnSelected($event) (removeColumn)=removeColumn($event)>\n              </nxt-datatable>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- List -->\n      <!-- AP-06MAR25 - List data show-->\n      <div *ngIf=\"field.type === 'List'\" class=\"field-container\" (click)=\"selectElement(i)\"\n        [ngStyle]=\"getFontStyles(field)\" [class.highlight]=\"selectedFieldIndex === i\" draggable=\"true\"\n        (dragstart)=\"onDragStart($event, i)\" (dragover)=\"onDragOver($event, i)\" (drop)=\"onDrop($event, i)\">\n        <div class=\"field-wrapper\">\n          <div class=\"field-content\">\n            <div class=\"label-container\">\n              <div>\n                <label [class.required]=\"field.isRequired\" *ngIf=\"field.style?.showLabel !== false\">{{\n                  field.questionText ? field.questionText : 'Label' }}</label>\n              </div>\n              <div class=\"top-right\">\n                <img src=\"../assets/icons/drag-dots.svg\" alt=\"Drag\" class=\"drag-dot\" />\n                <img src=\"../assets/icons/Trash.svg\" (click)=\"removeElement(field, i)\" class=\"delete-icon\" />\n              </div>\n            </div>\n            <input type=\"text\" class=\"custom-input\" placeholder=\"Search...\" [readonly]=\"field.isReadOnly\"\n              [class.hidden]=\"field.isHidden\" [value]=\"field.defaultValue ? field.defaultValue : ''\" />\n          </div>\n        </div>\n      </div>\n\n    </ng-container>\n  </div>\n</div>\n<!-- SKS13MAR25 popup conformation box -->\n<div class=\"dialog-overlay\" *ngIf=\"isSelectTablePopup\">\n  <div class=\"dialog-box\">\n    <button class=\"close-btn-fb\" (click)=\"onClose()\">✕</button>\n    <p>These element want to add a table</p>\n    <div class=\"button-container-fb\">\n      <button class=\"yes-btn-fb\" (click)=\"addOnTable()\">Yes</button>\n      <button class=\"no-btn-fb\" (click)=\"onClose()\">No</button>\n    </div>\n  </div>\n</div>"]}