@tsi-developpement/tsi-shared-ui 1.10.20 → 1.10.22

package/esm2022/lib/tsi-components/input-components/editable-grid/editable-grid.component.mjs

@@ -402,11 +402,23 @@ export class EditableGridComponent extends TsiInputBase {
         if (this._isAutoRowNumber) {
             duplicatedRow[this._autoRowNumberField] = this._nextRowNumber();
         }
-        this.gridData.push(duplicatedRow);
-        this.isDirty = true;
         if (this.editableTable?.sortField && this.editableTable.sortOrder) {
-            this.editableTable?.value.push(duplicatedRow);
+            const tableIndex = this.editableTable.value.indexOf(item, 0);
+            if (tableIndex > -1) {
+                this.editableTable.value.splice(tableIndex + 1, 0, duplicatedRow);
+            }
+            else {
+                this.editableTable.value.push(duplicatedRow);
+            }
+        }
+        const dataIndex = this.gridData.indexOf(item, 0);
+        if (dataIndex > -1) {
+            this.gridData.splice(dataIndex + 1, 0, duplicatedRow);
         }
+        else {
+            this.gridData.push(duplicatedRow);
+        }
+        this.isDirty = true;
         this.refreshSort();
         if (updateSelection) {
             this.selectedItem = duplicatedRow;
@@ -415,7 +427,7 @@ export class EditableGridComponent extends TsiInputBase {
                 : duplicatedRow;
         }
         const result = {
-            rowNumber: this.gridData.length - 1,
+            rowNumber: this.gridData.indexOf(duplicatedRow),
             data: duplicatedRow
         };
         if (!skipEmit) {
@@ -892,4 +904,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: HostListener,
                 args: ['document:keydown', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable-grid.component.js","sourceRoot":"","sources":["../../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/input-components/editable-grid/editable-grid.component.ts","../../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/input-components/editable-grid/editable-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, HostListener, inject, Input, OnDestroy, OnInit, Output, ViewChild } from '@angular/core';\r\nimport { FilterService, SortEvent, TableState } from 'primeng/api';\r\nimport { Table, TableRowSelectEvent, TableRowUnSelectEvent } from 'primeng/table';\r\nimport { Observable, Subscription } from 'rxjs';\r\nimport { rtlModeKeys } from '../../../consts/locals.const';\r\nimport { ButtonType, GridSelectionMode, InputTypes, ModalSizeEnum, TooltipPosition } from '../../../enums';\r\nimport { preciseAdd, preciseSum } from '../../../functions';\r\nimport { CellChangedResult, GridColumn, IGridConfiguration, RowAddedResult } from '../../../interfaces';\r\nimport { LocalizePipe } from '../../../pipes/localize.pipe';\r\nimport { CollectionChangeAction, CollectionChangedEvent, ObservableCollection } from '../../../models/collection/observable-collection';\r\nimport { EntityValidationsService } from '../../../services/validation/entity-validations.service';\r\nimport { GenericValidationStateService } from '../../../services';\r\nimport { FormState } from '../../../models/form/form-state';\r\nimport { TsiInputBase } from '../../../tsi-base/tsi-input-base/tsi-input-base.component';\r\nimport { ColumnWidthController } from '../../../tsi-helpers/column-width.controller';\r\nimport { GridSizingMode } from '../../../enums/grid-sizing-mode';\r\nimport { LayoutHelperService } from '../../../services/layout/layout-helper.service';\r\n\r\n@Component({\r\n  selector: 'Tsi-Generic-Editable-Grid',\r\n  templateUrl: './editable-grid.component.html',\r\n  styleUrls: ['./editable-grid.component.scss'],\r\n  providers: [GenericValidationStateService]\r\n})\r\nexport class EditableGridComponent extends TsiInputBase implements OnInit, OnDestroy {\r\n\r\n  //#region local vars\r\n  //#region private local vars\r\n  private saveEventSubscription?: Subscription;\r\n  private _isAutoRowNumber: boolean = false;\r\n  private _autoRowNumberField: string = '';\r\n  private _currentRowNumber: number = 0;\r\n  tooltipPosition = TooltipPosition;\r\n  isAr: boolean = false;\r\n  private _gridData: Array<any> = [];\r\n  private _equatableFields: Array<string> | undefined;\r\n  private _sumAtFusionFields: Array<string> | undefined;\r\n  private _equalityCheckOn: boolean = false;\r\n  private _f6SourceRow: any = null;\r\n  private _pendingDuplicateEmitTimer: ReturnType<typeof setTimeout> | null = null;\r\n  private _pendingDuplicateResult: RowAddedResult | null = null;\r\n  private static readonly SEARCH_LABEL_PREFIX = '__search_label__';\r\n\r\n  /**\r\n   * Name of the custom PrimeNG filter registered for global search.\r\n   * Extends the built-in 'contains' with locale-aware decimal matching\r\n   * (comma vs dot separator) while keeping full protection against false\r\n   * positives on text columns.\r\n   * @see _registerGridContainsFilter\r\n   */\r\n  private static readonly DECIMAL_AWARE_CONTAINS_FILTER = 'grid-contains';\r\n  multipleGridSelectionMode = GridSelectionMode.Multiple;\r\n  searchValue: string = '';\r\n  globalFilterFields: string[] = [];\r\n  //#endregion\r\n  inputTypes = InputTypes;\r\n  modalSize = ModalSizeEnum.ExtraLarge;\r\n  @ViewChild(\"editableTable\") editableTable?: Table\r\n\r\n  buttonType = ButtonType;\r\n\r\n  @Input() selectedItems: any = [];\r\n  selectedItem: any;\r\n\r\n  //#endregion\r\n\r\n  //#region Inputs\r\n  @Input('configuration') configuration?: IGridConfiguration;\r\n  @Input('key') key: string = 'uid';\r\n  @Input() items: Array<any> = [];\r\n  @Input() saveEvent?: Observable<void>;\r\n  /**\r\n   * Controls the visibility of the global search bar in the grid caption.\r\n   *\r\n   * When `true`, a search input and button are displayed, allowing users to\r\n   * filter rows across all visible columns simultaneously. Supports plain text,\r\n   * dropdown labels (resolved via shadow fields), and decimal values with\r\n   * locale-aware comma/dot matching.\r\n   *\r\n   * Defaults to `false` to preserve the existing behaviour for all consumers\r\n   * that do not explicitly opt in — enabling it on a specific grid is as simple\r\n   * as adding `[showGlobalSearch]=\"true\"`.\r\n   */\r\n  @Input() showGlobalSearch: boolean = false;\r\n\r\n  @Input() showAddButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showDeleteButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showEditButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showRowSummary: boolean = false;//TO DO Save Button Option\r\n\r\n  @Input() scrollHeight: string = '500px';\r\n\r\n  /**\r\n   * Fill (default): the table stretches to fill its container. Hug: the table shrinks to\r\n   * its columns' size (never wider than the container), leaving leftover width empty.\r\n   */\r\n  @Input() sizingMode: GridSizingMode = GridSizingMode.Fill;\r\n\r\n  /**\r\n   * Sizing style bound to the p-table's `[tableStyle]` — the single lever that distinguishes\r\n   * Fill from Hug (see GridSizingMode). Applied inline on the PrimeNG table, so it beats\r\n   * PrimeNG's default `.p-datatable-table { width: 100% }` with no `!important`/`::ng-deep`.\r\n   * - Fill: default (no forced width; PrimeNG fills the container).\r\n   * - Hug: `width:auto` shrinks the table to its columns; `max-width:100%` keeps it inside the\r\n   *   page (overflow scrolls); `min-width:0` avoids any inherited floor.\r\n   *\r\n   * Hug + `columnResizeMode=\"expand\"`: dragging a column resizes that column, but `width:auto`\r\n   * is re-asserted on change detection, so the table itself stays hugged and never expands.\r\n   */\r\n  get tableStyle(): { [key: string]: string } {\r\n    return this.sizingMode === GridSizingMode.Hug\r\n      ? { 'width': 'auto', 'min-width': '0', 'max-width': '100%' }\r\n      : {};\r\n  }\r\n  @Input() rowPerPage: number[] = [5, 10, 20];\r\n  // @Input() isPaginator: boolean = true;\r\n  @Input() pageSize: number = 5\r\n  @Input() entityPrimaryKeyName : string = 'uid'\r\n\r\n  private _selectedColumns: Array<GridColumn> = [];\r\n\r\n  get selectedColumns(): Array<GridColumn> {\r\n    return this._selectedColumns;\r\n  }\r\n\r\n  set selectedColumns(value: Array<GridColumn>) {\r\n    this._selectedColumns = value;\r\n    this._syncGlobalFilterFields();\r\n  }\r\n\r\n  private _columns: Array<GridColumn> = [];\r\n  private _tempColumns: Array<GridColumn> = [];\r\n  private _columnsChangedSubscription?: Subscription;\r\n\r\n  get columns(): Array<GridColumn> {\r\n    return this._columns;\r\n  }\r\n\r\n  @Input() set columns(value: Array<GridColumn> | ObservableCollection<GridColumn>) {\r\n    this._columnsChangedSubscription?.unsubscribe();\r\n\r\n    const isObservable = (value as ObservableCollection<GridColumn>).isObservableCollection === true;\r\n    const items = isObservable ? (value as ObservableCollection<GridColumn>).toArray() : value as Array<GridColumn>;\r\n    items.forEach(el => el.translatedHeader = this._localizePipe.transform(el.header ?? \"\"));\r\n    this._columns = items;\r\n    this.selectedColumns = [...items];\r\n\r\n    if (isObservable) {\r\n      this._columnsChangedSubscription = (value as ObservableCollection<GridColumn>).changed.subscribe(event => {\r\n        console.log(\"event changed => \", event)\r\n        this._onColumnsChanged(event)\r\n      });\r\n    }\r\n\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n  @Input() set gridData(data: Array<any>) {\r\n    this._gridData = data;\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n  get gridData() { return this._gridData; }\r\n\r\n  @Input() isTableLoading?: boolean;\r\n\r\n\r\n  @Input() parent: any;\r\n\r\n  @Input() showSaveButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showActionColumn: boolean = true;//TO DO Save Button Option\r\n\r\n\r\n  @Input() enableRowDisabling: boolean = false;\r\n\r\n  @Input() rowSummaryConfig: Array<string> = [];\r\n  @Input() showHaveSumary?: boolean = false;\r\n  @Input() showRowSumary?: boolean = false;\r\n\r\n  /**selection */\r\n  @Input() selectKeyOnly: boolean = true;\r\n  @Input() selectionMode: GridSelectionMode | any = GridSelectionMode.Single;\r\n  @Input() showConsultButton: boolean = false;\r\n\r\n  private _editableGridBusinessClass: string = \"\";\r\n  get editableGridBusinessClass() {\r\n    return this._editableGridBusinessClass;\r\n  }\r\n  @Input() set editableGridBusinessClass(className: string) {\r\n    this._editableGridBusinessClass = className;\r\n    this.genericValidationStateService?.loadEntityValidationInfos(this._editableGridBusinessClass);\r\n  }\r\n\r\n\r\n  /**order */\r\n  @Input() orderColumn: string = 'uid';\r\n\r\n  @Input() deleteLineButtonDisabled!: (item: any) => any\r\n\r\n  @Input() showDuplicateButton: boolean = true;\r\n\r\n  //#endregion\r\n\r\n  //#region Outputs\r\n\r\n  @Output() refreshEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  //@Output() actionEventEmitter: EventEmitter<GridActionEmitResult> = new EventEmitter<GridActionEmitResult>();\r\n\r\n  @Output() saveDataEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() rowChangedEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() selectedRowEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() addedRowEventEmitter: EventEmitter<RowAddedResult> = new EventEmitter<RowAddedResult>()\r\n\r\n  @Output() focusOutEventEmitter = new EventEmitter<string>();\r\n\r\n  @Output() cellChanged: EventEmitter<CellChangedResult> = new EventEmitter<CellChangedResult>();\r\n\r\n  @Output() rowDeletedEventEmitter = new EventEmitter<any>();\r\n\r\n  @Output() selectedItemsChange: EventEmitter<Array<any>> = new EventEmitter<Array<any>>();\r\n\r\n  @Output() onRowSelect: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() focusOutRow: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() onConsultClicked: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() rowDuplicatedEventEmitter: EventEmitter<RowAddedResult> = new EventEmitter<RowAddedResult>();\r\n  //#endregion\r\n\r\n  @ViewChild(\"dt\", { static: false }) public dt: Table | undefined;\r\n\r\n  @Input() id?: string;\r\n\r\n  /**\r\n   * Tracks rows by their business key (`key` input) so PrimeNG reuses existing row views\r\n   * instead of destroying/recreating them when the row array is replaced with objects sharing\r\n   * the same key (e.g. after a recalculation that clones the data). Without this, every cell\r\n   * editor — including server-backed search combos — is re-instantiated and re-fetches its data.\r\n   * Falls back to the row index when the key is absent (e.g. brand-new rows).\r\n   * Arrow property so `this` is preserved when PrimeNG invokes it.\r\n   */\r\n  rowTrackBy = (index: number, item: any): any => item?.[this.key] ?? index;\r\n\r\n  private _entityValidationsService = inject(EntityValidationsService);\r\n  private _stripedRowsLayoutHelperService = inject(LayoutHelperService);\r\n\r\n  constructor(private _localizePipe: LocalizePipe, private _filterService: FilterService) {\r\n    super();\r\n    this._registerGridContainsFilter();\r\n  }\r\n\r\n  get stripedRows(): boolean {\r\n    return this._stripedRowsLayoutHelperService.layoutConfiguration.isStripedRowsEnabled;\r\n  }\r\n\r\n  override ngOnInit() {\r\n    super.ngOnInit()\r\n    this._initSaveEventSubscription();\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n    this._initEquatableFields();\r\n    this._initSumAtFusionFields();\r\n    \r\n    let langue = localStorage.getItem(rtlModeKeys.rtlModeEnabled);\r\n    \r\n    if (langue && JSON.parse(langue)) {\r\n      this.isAr = true\r\n    }\r\n    else {\r\n      this.isAr = false\r\n    }\r\n\r\n    if (!this.selectedColumns || this.selectedColumns.length == 0) {\r\n      this.selectedColumns = this.columns\r\n    }\r\n\r\n    this._tempColumns = this.columns;\r\n  }\r\n\r\n  findColumnByKey(key: any) {\r\n    if (this.columns) {\r\n      for (let col of this.columns) {\r\n        if (col.header === key || col.field === key) return col;\r\n        else continue;\r\n      }\r\n    }\r\n    return null\r\n  }\r\n\r\n\r\n  public restoreState(configuration: string) {\r\n    let state: TableState = JSON.parse(configuration)\r\n    if (this.dt) {\r\n      this.columnWidth.setRemembered(state.columnWidths);\r\n      this.dt.columnWidthsState = state.columnWidths;\r\n      this.dt.tableWidthState = state.tableWidth;\r\n\r\n      let columnOrder = state.columnOrder;\r\n\r\n      if (columnOrder) {\r\n        let reorderedColumns = this.getReorderedColumns(columnOrder);\r\n        if (reorderedColumns.length > 0) {\r\n          this.selectedColumns = reorderedColumns;\r\n        }\r\n      }\r\n\r\n      // Apply the remembered column widths to the DOM. Assigning columnWidthsState\r\n      // alone is a no-op here because the grid is not PrimeNG-\"stateful\" (no stateKey).\r\n      this.dt.restoreColumnWidths();\r\n    }\r\n  }\r\n\r\n  getReorderedColumns(columnOrder: string[]): any[] {\r\n    let reorderedColumns: any[] = [];\r\n\r\n    columnOrder.map((key) => {\r\n      let col = this.findColumnByKey(key);\r\n      if (col) {\r\n        reorderedColumns.push(col);\r\n      }\r\n    });\r\n\r\n    return reorderedColumns;\r\n  }\r\n\r\n  resetSelectedColumns(configuration: string) {\r\n    let state: TableState = JSON.parse(configuration)\r\n    if (this.dt) {\r\n      this.columnWidth.reset();\r\n      this.columnWidth.setRemembered(state.columnWidths);\r\n      this.dt.columnWidthsState = state.columnWidths;\r\n      this.dt.tableWidthState = state.tableWidth;\r\n\r\n      let columnOrder = state.columnOrder;\r\n\r\n      if (columnOrder) {\r\n        let reorderedColumns = this.getReorderedColumns(columnOrder);\r\n        this.selectedColumns = reorderedColumns.length > 0 ? reorderedColumns : [...this._columns];\r\n      }\r\n\r\n      this.dt.restoreColumnWidths();\r\n    }\r\n  }\r\n\r\n  getState() {\r\n    let state: TableState = {};\r\n\r\n    if (!this.dt) {\r\n      return\r\n    }\r\n\r\n    if (this.dt.resizableColumns) {\r\n      this.dt.saveColumnWidths(state);\r\n    }\r\n\r\n    this.dt.saveColumnOrder(state);\r\n\r\n    return state\r\n  }\r\n\r\n  /**\r\n   * Shared model for the developer-width / wrapping / resize-priority behavior. Action/button\r\n   * columns and frozen columns are excluded (frozen columns must keep their sticky-offset\r\n   * width or later frozen columns misalign); all other columns are eligible.\r\n   */\r\n  private readonly columnWidth = new ColumnWidthController((col) => !col.isButton && !col.isFrozen);\r\n\r\n  /** Remember which column the user resized so its developer-preferred width yields. */\r\n  onColResize(event: { element?: HTMLElement; delta?: number }): void {\r\n    this.columnWidth.onResize(event?.element?.getAttribute('data-field'));\r\n  }\r\n\r\n  /** Whether a column's content should wrap to stay inside its constrained width. */\r\n  shouldWrapColumn(col: GridColumn): boolean {\r\n    return this.columnWidth.shouldWrap(col);\r\n  }\r\n\r\n  /**\r\n   * Developer size style only, bound via `[ngStyle]` on the header/summary cells alongside\r\n   * their untouched `[style]=\"col.style\"` (so a string `col.style` is never spread/broken).\r\n   */\r\n  getColumnSizeStyle(col: GridColumn): { [key: string]: string } {\r\n    return this.columnWidth.sizeStyle(col);\r\n  }\r\n\r\n  /** Body `<td>` style: RTL alignment + top-align (eligible cells) + developer size style. */\r\n  getBodyColumnStyle(col: GridColumn): { [key: string]: any } {\r\n    const base = this.isAr ? { 'text-align': 'start' } : {};\r\n    return { ...base, ...this.columnWidth.verticalAlign(col), ...this.columnWidth.sizeStyle(col) };\r\n  }\r\n\r\n  isDeleteButtonDisabled(item: any) {\r\n    if (this.deleteLineButtonDisabled != undefined) {\r\n      return this.deleteLineButtonDisabled(item)\r\n    }\r\n  }\r\n\r\n  override ngOnDestroy(): void {\r\n    super.ngOnDestroy()\r\n    this.saveEventSubscription?.unsubscribe();\r\n    this._cancelPendingDuplicateEmit();\r\n    this._columnsChangedSubscription?.unsubscribe();\r\n  }\r\n\r\n  private _onColumnsChanged(event: CollectionChangedEvent<GridColumn>): void {\r\n    switch (event.action) {\r\n      case CollectionChangeAction.Add: {\r\n        if (event.newItems && event.newStartingIndex !== undefined) {\r\n          event.newItems.forEach(col =>\r\n            col.translatedHeader = this._localizePipe.transform(col.header ?? \"\")\r\n          );\r\n          const prevSelected = new Set(this.selectedColumns);\r\n          const newColumns = [...this._columns];\r\n          newColumns.splice(event.newStartingIndex, 0, ...event.newItems);\r\n          this._columns = newColumns;\r\n          this.selectedColumns = this._columns.filter(\r\n            c => prevSelected.has(c) || event.newItems!.includes(c)\r\n          );\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Remove: {\r\n        if (event.oldItems) {\r\n          const removed = new Set(event.oldItems);\r\n          this._columns = this._columns.filter(c => !removed.has(c));\r\n          this.selectedColumns = this.selectedColumns.filter(c => !removed.has(c));\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Replace: {\r\n        if (event.newItems && event.oldItems && event.newStartingIndex !== undefined) {\r\n          event.newItems.forEach(col =>\r\n            col.translatedHeader = this._localizePipe.transform(col.header ?? \"\")\r\n          );\r\n          const prevSelected = new Set(this.selectedColumns);\r\n          const removedOld = new Set(event.oldItems);\r\n          const newColumns = [...this._columns];\r\n          newColumns.splice(event.newStartingIndex, event.oldItems.length, ...event.newItems);\r\n          this._columns = newColumns;\r\n          this.selectedColumns = this._columns.filter(\r\n            c => (prevSelected.has(c) && !removedOld.has(c)) || event.newItems!.includes(c)\r\n          );\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Reset:\r\n      default: {\r\n        this._columns = [];\r\n        this.selectedColumns = [];\r\n        break;\r\n      }\r\n    }\r\n\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n\r\n  saveItems() {\r\n    const clean = this._cleanGridDataForEmit();\r\n    this.saveDataEventEmitter.emit(clean);\r\n  }\r\n\r\n  addRow(): void {\r\n    if (!this.gridData) {\r\n      this.gridData = [];\r\n    }\r\n    let newRow = this._initRow()\r\n    this.gridData.push(newRow)\r\n    this.isDirty = true\r\n    let rowAddedResult: RowAddedResult = {\r\n      rowNumber: this.gridData.length - 1,\r\n      data: newRow\r\n    }\r\n\r\n    if (this.editableTable?.sortField && this.editableTable.sortOrder) {\r\n      this.editableTable?.value.push(newRow)\r\n    }\r\n    this.refreshSort()\r\n    this.addedRowEventEmitter.emit(rowAddedResult)\r\n  }\r\n\r\n  duplicateRow(item: any, updateSelection: boolean = true, skipEmit: boolean = false): RowAddedResult | null {\r\n    if (!item) return null;\r\n\r\n    const duplicatedRow = JSON.parse(JSON.stringify(item));\r\n    duplicatedRow[this.entityPrimaryKeyName] = undefined;\r\n    \r\n    for (const col of this.columns) {\r\n      if (col.excludeOnDuplicate && Object.prototype.hasOwnProperty.call(duplicatedRow, col.field)) {\r\n        duplicatedRow[col.field] = undefined;\r\n      }\r\n    }\r\n\r\n    if (this._isAutoRowNumber) {\r\n      duplicatedRow[this._autoRowNumberField] = this._nextRowNumber();\r\n    }\r\n\r\n    this.gridData.push(duplicatedRow);\r\n    this.isDirty = true;\r\n\r\n    if (this.editableTable?.sortField && this.editableTable.sortOrder) {\r\n      this.editableTable?.value.push(duplicatedRow);\r\n    }\r\n\r\n    this.refreshSort();\r\n\r\n    if (updateSelection) {\r\n      this.selectedItem = duplicatedRow;\r\n      this.selectedItems = this.selectionMode == GridSelectionMode.Multiple\r\n        ? [duplicatedRow]\r\n        : duplicatedRow;\r\n    }\r\n\r\n    const result: RowAddedResult = {\r\n      rowNumber: this.gridData.length - 1,\r\n      data: duplicatedRow\r\n    };\r\n\r\n    if (!skipEmit) {\r\n      this.addedRowEventEmitter.emit(result);\r\n      this.rowDuplicatedEventEmitter.emit(result);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  refreshSort() {\r\n    if (this.editableTable?.sortField) {\r\n      const sortField = this.editableTable.sortField;\r\n      const sortOrder = this.editableTable.sortOrder;\r\n\r\n      this.gridData.sort((a, b) => {\r\n        const valueA = a[sortField];\r\n        const valueB = b[sortField];\r\n        let result = 0;\r\n\r\n        if (valueA < valueB) result = -1;\r\n        else if (valueA > valueB) result = 1;\r\n\r\n        return result * sortOrder;\r\n      });\r\n\r\n      this.gridData = [...this.gridData];\r\n    }\r\n  }\r\n\r\n  delete(item: any) {\r\n    if (this.editableTable?.sortField && this.editableTable.sortMode) {\r\n      const index = this.editableTable.value.indexOf(item, 0);\r\n      if (index > -1) {\r\n        this.editableTable.value.splice(index, 1)\r\n      }\r\n    }\r\n    const index = this.gridData.indexOf(item, 0);\r\n    if (index > -1) {\r\n      this.gridData.splice(index, 1);\r\n      this.isDirty = true\r\n      this._onDeleteRow(item);\r\n      this.rowDeletedEventEmitter.emit(this._cleanGridDataForEmit())\r\n    }\r\n    this.refreshSort()\r\n  }\r\n\r\n  getSummary(col: GridColumn): number {\r\n    if (col.haveSummary == true) {\r\n      return preciseSum((this.gridData ?? []).map((row: any) => row[col.field]));\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  rowSummary(row: any): number {\r\n    return preciseSum(this.columns.filter(col => col.rowSummary == true).map(col => row[col.field]));\r\n  }\r\n\r\n  onRowSelected(event: TableRowSelectEvent) {\r\n    this.selectedItem = event.data;\r\n    this._f6SourceRow = null;\r\n    this._cancelPendingDuplicateEmit();\r\n    if (this.selectKeyOnly == true) {\r\n      let selectionKey: any;\r\n      selectionKey = this.selectedItem[this.key];\r\n      this.onRowSelect.emit(selectionKey);\r\n    }\r\n    else {\r\n      this.onRowSelect.emit(this.selectedItems);\r\n    }\r\n  }\r\n\r\n  onRowUnselect(event: TableRowUnSelectEvent) {\r\n    this.selectedItem = undefined;\r\n    this._f6SourceRow = null;\r\n    this._cancelPendingDuplicateEmit();\r\n  }\r\n\r\n  selectionChange(event: any) {\r\n\r\n    let selection: any[] = [];\r\n\r\n    if (this.selectionMode == GridSelectionMode.Multiple) {\r\n      if (this.selectedItems) {\r\n        if (this.selectKeyOnly) {\r\n          let keys: Array<any> = [];\r\n          this.selectedItems.forEach((v: any) => { keys.push(v[this.key]) });\r\n          selection = keys;\r\n        }\r\n        else {\r\n          selection = this.selectedItems;\r\n        }\r\n      }\r\n      else {\r\n        selection = [];\r\n      }\r\n    }\r\n    else if (this.selectionMode == GridSelectionMode.Single) {\r\n      if (this.selectKeyOnly) {\r\n        selection = this.selectedItems ? [this.selectedItems[this.key]] : [];\r\n      }\r\n      else {\r\n        selection = this.selectedItems ? [this.selectedItems] : [];\r\n      }\r\n    }\r\n\r\n    if (this.selectionMode != GridSelectionMode.None) {\r\n      this.selectedItemsChange.emit(selection)\r\n    }\r\n  }\r\n\r\n  handleKeydown(event: KeyboardEvent) {\r\n    if (event.code === 'Space') {\r\n      event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  @HostListener('document:keydown', ['$event'])\r\n  handleGridKeydown(event: KeyboardEvent): void {\r\n    if (event.key === 'F6') {\r\n      event.preventDefault();\r\n\r\n      const source = this._f6SourceRow ?? this.selectedItem;\r\n      if (!source) return;\r\n\r\n      const isFirstDuplicate = !this._f6SourceRow;\r\n      this._f6SourceRow = source;\r\n\r\n      const result = this.duplicateRow(source, isFirstDuplicate, true);\r\n\r\n      if (result && !this._pendingDuplicateResult) {\r\n        this._pendingDuplicateResult = result;\r\n      }\r\n\r\n      if (this._pendingDuplicateEmitTimer) {\r\n        clearTimeout(this._pendingDuplicateEmitTimer);\r\n      }\r\n\r\n      this._pendingDuplicateEmitTimer = setTimeout(() => {\r\n        this._pendingDuplicateEmitTimer = null;\r\n        if (this._pendingDuplicateResult) {\r\n          this.addedRowEventEmitter.emit(this._pendingDuplicateResult);\r\n          this.rowDuplicatedEventEmitter.emit(this._pendingDuplicateResult);\r\n          this._pendingDuplicateResult = null;\r\n        }\r\n      }, 300);\r\n    }\r\n  }\r\n\r\n  onFocusOutRow(item: any) {\r\n    this.focusOutRow.emit(item);\r\n  }\r\n\r\n  customSort(event: SortEvent) {\r\n    if (event.data != null && event.data != undefined) {\r\n      event.data.sort((data1, data2) => {\r\n        if (event.field != null && event.field != undefined && event.order) {\r\n          let value1 = data1[event.field];\r\n          let value2 = data2[event.field];\r\n          let result = null;\r\n\r\n          if (value1 == null && value2 != null)\r\n            result = -1;\r\n          else if (value1 != null && value2 == null)\r\n            result = 1;\r\n          else if (value1 == null && value2 == null)\r\n            result = 0;\r\n          else if (typeof value1 === 'string' && typeof value2 === 'string')\r\n            result = value1.localeCompare(value2);\r\n          else\r\n            result = (value1 < value2) ? -1 : (value1 > value2) ? 1 : 0;\r\n\r\n          return (event.order * result);\r\n        }\r\n        return 0;\r\n      });\r\n    }\r\n  }\r\n\r\n  consult(key: string): void {\r\n    this.onConsultClicked.emit(key);\r\n  }\r\n\r\n  onCellLabelResolved(col: GridColumn, label: string, item: any): void {\r\n    item[this._getShadowSearchColumnLabel(col)] = label;\r\n  }\r\n\r\n  onCellValueChanged(col: GridColumn, newValue: any, item: any): void {\r\n    // Mark the grid itself dirty on any genuine cell edit. The grid instance lives\r\n    // for the whole form lifetime, so this flag survives row-data reassignment\r\n    // during recalculation (where transient cell inputs are recreated and lose\r\n    // their own isDirty), keeping the save-time change detection accurate.\r\n    this.isDirty = true;\r\n    if (col.type === InputTypes.SEARCH_COMBO && newValue == null) {\r\n      delete item[this._getShadowSearchColumnLabel(col)];\r\n    }\r\n    // send events\r\n    if (col.watchForChanges === true) {\r\n\r\n      let cellChangedResult: CellChangedResult = {\r\n        key: item[this.key],\r\n        field: col.field,\r\n        newValue: newValue\r\n      }\r\n      this.cellChanged.emit(cellChangedResult);\r\n    }\r\n\r\n    // recalculate currentRowNumber\r\n    if (col.field === this._autoRowNumberField) {\r\n      this._orderByRowNumber();\r\n    }\r\n\r\n    // check for duplicated rows\r\n    // if(this._equalityCheckOn && col.isEquatableCriteria){\r\n    //   console.log('found equatable : col:', col, 'row : ', item);\r\n    //   this._tryFindEquatable(item);\r\n    // }\r\n  }\r\n\r\n  public updateFormState(formState: FormState): void {\r\n    if (!this.genericValidationStateService) {\r\n      return;\r\n    }\r\n\r\n    this.genericValidationStateService.updateFormState(formState);\r\n  }\r\n\r\n  applyGlobalSearch(): void {\r\n    this.dt?.filterGlobal(this.searchValue, EditableGridComponent.DECIMAL_AWARE_CONTAINS_FILTER);\r\n  }\r\n\r\n  //#region private methods\r\n\r\n  private _initRow() {\r\n    let newRow: any = {};\r\n    if (this.columns) {\r\n      this.columns.forEach(col => {\r\n        if (col.type == InputTypes.DECIMAL_INPUT\r\n          || col.type == InputTypes.RATE_INPUT\r\n          || col.type == InputTypes.INTEGER\r\n          || col.type == InputTypes.CURRENCY_SOCIETE_INPUT\r\n          || col.type == InputTypes.CURRENCY_OTHER_INPUT) {\r\n          newRow[col.field] = 0;\r\n        }\r\n        else if (col.type == InputTypes.CHECKBOX) {\r\n          newRow[col.field] = false;\r\n        }\r\n        else {\r\n          newRow[col.field] = undefined;\r\n        }\r\n      });\r\n\r\n      if (this._isAutoRowNumber === true) {\r\n        newRow[this._autoRowNumberField] = this._nextRowNumber();\r\n      }\r\n      return newRow\r\n    }\r\n    return newRow;\r\n  }\r\n\r\n  private _initSaveEventSubscription() {\r\n    this.saveEventSubscription = this.saveEvent?.subscribe(\r\n      () => this.saveItems()\r\n    );\r\n  }\r\n\r\n  private _verifyGridRequirements() {\r\n    if (this.columns == null\r\n      || this.columns == undefined) {\r\n      throw new Error('grid columns can\\'t be null')\r\n    }\r\n    \r\n    let rowNumberColumns = this.columns.filter(c => c.isAutoRowNumberColumn === true);\r\n\r\n    if (rowNumberColumns.length > 1) {\r\n      throw new Error('grid columns can\\'t have more than one RowNumberColumn')\r\n    }\r\n    \r\n    if (rowNumberColumns.length == 1) {\r\n      this._isAutoRowNumber = true;\r\n      this._autoRowNumberField = rowNumberColumns[0].field;\r\n    }\r\n  }\r\n\r\n  private _initCurrentRowNumberAndOrderByRowNumber(): void {\r\n    if (this._isAutoRowNumber === true\r\n      && this._autoRowNumberField != undefined\r\n      && this._autoRowNumberField != null\r\n      && this.gridData.length > 0) {\r\n      this._orderByRowNumber();\r\n\r\n      this._currentRowNumber = this.gridData[this.gridData.length - 1][this._autoRowNumberField];\r\n    }\r\n  }\r\n\r\n  private _nextRowNumber(): number {\r\n    this._currentRowNumber = this.gridData.length + 1;\r\n    return this._currentRowNumber;\r\n  }\r\n\r\n  private _onDeleteRow(row: any): void {\r\n    if (row[this._autoRowNumberField] === this._currentRowNumber) {\r\n      this._currentRowNumber--;\r\n    }\r\n  }\r\n\r\n  private _orderByRowNumber(): void {\r\n    this.gridData.sort((a, b) => { return a[this._autoRowNumberField] - b[this._autoRowNumberField]; });\r\n  }\r\n\r\n  private _initEquatableFields(): void {\r\n    let equatableColumns = this.columns.filter(c => c.isEquatableCriteria == true);\r\n    if (equatableColumns) {\r\n      this._equalityCheckOn = true;\r\n      this._equatableFields = equatableColumns.map(c => c.field);\r\n    }\r\n  }\r\n\r\n  private _initSumAtFusionFields(): void {\r\n    let sumAtFusionColumns = this.columns.filter(c => c.isSumAtFusion == true);\r\n    if (sumAtFusionColumns) {\r\n      this._equalityCheckOn = true;\r\n      this._sumAtFusionFields = sumAtFusionColumns.map(c => c.field);\r\n    }\r\n  }\r\n\r\n  private _tryFindEquatable(row: any): void {\r\n    let foundEqualRow: boolean = false;\r\n    for (let i: number = 0; i < this.gridData.length; i++) {\r\n      console.log('proc row : ', this.gridData[i]);\r\n      let isCurrentRowEqual: boolean = true;\r\n      this._equatableFields?.forEach(f => {\r\n        console.log('proc field : ', f);\r\n        if (this.gridData[i][f] != row[f]) {\r\n          console.log('not equal ', row, this.gridData[i]);\r\n          isCurrentRowEqual = false;\r\n        }\r\n      });\r\n      if (isCurrentRowEqual) {\r\n        this._fusionRows(this.gridData[i], row);\r\n        foundEqualRow = true;\r\n        break;\r\n      }\r\n    }\r\n    if (foundEqualRow) {\r\n      console.log('deleting : ', row);\r\n      this.delete(row);\r\n    }\r\n  }\r\n\r\n  private _fusionRows(row1: any, row2: any) {\r\n    this._sumAtFusionFields?.forEach(f => {\r\n      row1[f] = preciseAdd(row1[f], row2[f]);\r\n    });\r\n  }\r\n\r\n  private _cancelPendingDuplicateEmit(): void {\r\n    this._pendingDuplicateResult = null;\r\n    if (this._pendingDuplicateEmitTimer) {\r\n      clearTimeout(this._pendingDuplicateEmitTimer);\r\n      this._pendingDuplicateEmitTimer = null;\r\n    }\r\n  }\r\n\r\n  private _syncGlobalFilterFields(): void {\r\n    const fields: string[] = [];\r\n    for (const col of this.selectedColumns) {\r\n      if (col.type === InputTypes.SEARCH_COMBO) {\r\n        fields.push(this._getShadowSearchColumnLabel(col));\r\n      } else {\r\n        fields.push(col.field);\r\n      }\r\n    }\r\n    this.globalFilterFields = fields;\r\n  }\r\n  \r\n  private _registerGridContainsFilter(): void {\r\n    // Custom PrimeNG filter used by applyGlobalSearch() instead of the built-in 'contains'.\r\n    // Extends the default behaviour with locale-aware decimal matching:\r\n    // a user in FR/AR locale types \"11,25\" but the stored JS number stringifies as \"11.25\",\r\n    // so a plain 'contains' check would miss it.\r\n    this._filterService.register(EditableGridComponent.DECIMAL_AWARE_CONTAINS_FILTER, (value: any, filter: string): boolean => {\r\n      if (filter == null || filter.trim() === '') return true;\r\n      if (value == null) return false;\r\n\r\n      const strValue = String(value).toLowerCase();\r\n      const strFilter = filter.trim().toLowerCase();\r\n\r\n      // Step 1 — direct match (handles all text columns and exact numeric matches)\r\n      if (strValue.includes(strFilter)) return true;\r\n\r\n      // Step 2 — decimal comma↔dot normalization.\r\n      // Two guards must both pass before normalizing:\r\n      //   • typeof value === 'number'  → only run on actual numeric values; text columns\r\n      //     containing dots (e.g. product codes like \"HP.XYZ\") are never touched.\r\n      //   • /^\\d+[,.]\\d+$/            → filter must look like a decimal number:\r\n      //       ^\\d+   one or more digits before the separator\r\n      //       [,.]   exactly one separator, comma or dot\r\n      //       \\d+$   one or more digits after the separator\r\n      //     This rejects free-text filters that happen to contain a comma (\"Caisse, France\")\r\n      //     and incomplete inputs (\"11,\" / \",25\").\r\n      if (typeof value === 'number' && /^\\d+[,.]\\d+$/.test(strFilter)) {\r\n        return strValue.includes(strFilter.replace(',', '.'));\r\n      }\r\n\r\n      return false;\r\n    });\r\n  }\r\n\r\n  private _cleanGridDataForEmit(): any[] {\r\n    return this.gridData.map(row => {\r\n      const clean: any = {};\r\n      for (const key of Object.keys(row)) {\r\n        if (!key.startsWith(EditableGridComponent.SEARCH_LABEL_PREFIX)) {\r\n          clean[key] = row[key];\r\n        }\r\n      }\r\n      return clean;\r\n    });\r\n  }\r\n\r\n  private _getShadowSearchColumnLabel(column: GridColumn): string {\r\n    return `${EditableGridComponent.SEARCH_LABEL_PREFIX}${column.field}`;\r\n  }\r\n  //#endregion\r\n}\r\n","<div class=\"card\">\r\n  <p-table #dt [selectionMode]=\"selectionMode\" [(selection)]=\"selectedItems\" editMode=\"row\"\r\n    [paginator]=\"gridData.length > pageSize\" [rowsPerPageOptions]=\"rowPerPage\" [rows]=\"pageSize\"\r\n    (onRowSelect)=\"onRowSelected($event)\" (onRowUnselect)=\"onRowUnselect($event)\" [scrollable]=\"true\"\r\n    (onColResize)=\"onColResize($event)\"\r\n    [resizableColumns]=\"true\" columnResizeMode=\"expand\" appendTo=\"body\" [value]=\"gridData\"\r\n    [columns]=\"selectedColumns\" [dataKey]=\"key\" [scrollHeight]=\"scrollHeight\" [styleClass]=\"'p-datatable-sm p-datatable-gridlines' + (stripedRows ? ' p-datatable-striped' : '')\"\r\n    (selectionChange)=\"selectionChange($event)\" #editableTable [totalRecords]=\"gridData.length\"\r\n    [globalFilterFields]=\"globalFilterFields\" [rowTrackBy]=\"rowTrackBy\" [tableStyle]=\"tableStyle\">\r\n\r\n    <ng-template pTemplate=\"caption\">\r\n      <div class=\"flex items-center gap-5 flex-row\">\r\n        <p-multiSelect [options]=\"columns\" [(ngModel)]=\"selectedColumns\"\r\n          selectedItemsLabel=\"{0} {{ 'columns_selected' | localize }}\" optionLabel=\"translatedHeader\"\r\n          [style]=\"{'min-width': '180px'}\" placeholder=\"{{ 'choose_columns' | localize }}\">\r\n          <ng-template let-option pTemplate=\"item\">\r\n            <div class=\"flex items-center gap-2\">\r\n              <span>{{ option.header | localize }}</span>\r\n            </div>\r\n          </ng-template>\r\n        </p-multiSelect>\r\n\r\n        <div *ngIf=\"showGlobalSearch\" class=\"flex items-center gap-1 w-8\">\r\n          <div presentationDesignerBase=\"global_search\" class=\"p-inputgroup rtl-mode h-2rem no-pad\">\r\n            <input class=\"\" type=\"text\" [(ngModel)]=\"searchValue\" pInputText class=\"border-round-lg\"\r\n              [placeholder]=\"'shared_edittable_search_placeholder' | localize\" (keydown.enter)=\"applyGlobalSearch()\">\r\n          </div>\r\n          <div presentationDesignerBase=\"search_button\">\r\n            <Tsi-Button styleClass=\"p-button-icon-only\" type=\"button\" icon=\"pi pi-search\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_search\"\r\n              (onClick)=\"applyGlobalSearch()\" />\r\n          </div>\r\n        </div>\r\n      </div> \r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"header\" let-columns>\r\n\r\n      <tr>\r\n        <ng-container *ngIf=\"selectionMode != multipleGridSelectionMode\">\r\n          <th pResizableColumn pFrozenColumn style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\"></th>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"selectionMode == multipleGridSelectionMode\">\r\n          <th pResizableColumn pFrozenColumn style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\">\r\n            <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n          </th>\r\n        </ng-container>\r\n        \r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n\r\n        <!-- <th pResizableColumn pFrozenColumn *ngIf=\"showEditButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th> -->\r\n        \r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showDuplicateButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showConsultButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showDeleteButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n\r\n        <th pResizableColumn pFrozenColumn [frozen]=\"col.isFrozen\" [style]=\"col.style\" [ngStyle]=\"getColumnSizeStyle(col)\" scope=\"col\"\r\n          [attr.data-field]=\"col.field\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\"\r\n          style=\"min-width:3rem;\" pSortableColumn=\"{{col.field}}\" *ngFor=\"let col of columns\"\r\n          pTooltip=\"{{col.toolTipText | localize }}\" tooltipPosition=\"top\" pReorderableColumn>{{ col.header | localize\r\n          }}\r\n          <p-sortIcon field=\"{{col.field}}\"></p-sortIcon>\r\n          <Tsi-Bubble-Info [infoText]=\"col.infoText | localize\"></Tsi-Bubble-Info>\r\n        </th>\r\n        <th style=\"min-width:3rem\" *ngIf=\"showRowSummary\" scope=\"col\">{{'RowSummary' | localize}}</th>\r\n      </tr>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"body\" let-item let-editing=\"editing\" let-columns=\"columns\" let-rowIndex=\"rowIndex\">\r\n      \r\n      <tr [pEditableRow]=\"item\"\r\n        *ngIf=\"selectionMode == multipleGridSelectionMode || selectionMode == undefined; else selectionModeBlock\"\r\n        (focusOut)=\"onFocusOutRow(item)\">\r\n        \r\n        <td style=\"text-align: center;\">\r\n          <p-tableCheckbox [value]=\"item\" ></p-tableCheckbox>\r\n        </td>\r\n\r\n        <!-- <td pFrozenColumn style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\"> -->\r\n\r\n\r\n        <!-- <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td> -->\r\n\r\n        <!-- <td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n          <div class=\"flex align-items-center justify-content-center\">\r\n            <button *ngIf=\"!editing\" pButton pRipple type=\"button\" pInitEditableRow icon=\"pi pi-pencil\"\r\n              class=\"p-button-rounded p-button-text\">\r\n            </button>\r\n            <button *ngIf=\"editing\" pButton pRipple type=\"button\" pSaveEditableRow icon=\"pi pi-check\"\r\n              class=\"p-button-rounded p-button-text p-button-success -ml-1\">\r\n            </button>\r\n            <button *ngIf=\"editing\" pButton pRipple type=\"button\" pCancelEditableRow icon=\"pi pi-times\"\r\n              class=\"p-button-rounded p-button-text p-button-danger -ml-2\">\r\n            </button>\r\n          </div>\r\n        </td> -->\r\n        <td pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\"></td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showDuplicateButton\" style=\"left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-copy\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_dupliquer\"\r\n              styleClass=\"p-button-rounded p-button-text p-button-info\" (click)=\"duplicateRow(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showConsultButton\" style=\"left: -1rem !important; width:3rem !important;\"\r\n          class=\"p-1 btn-consult-style\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-eye\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_consulter\"\r\n              styleClass=\"p-button-rounded p-button-text p-button-secondary\" (click)=\"consult(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showDeleteButton\"\r\n          style=\"left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1 btn-delete-style\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [disabled]=\"isDeleteButtonDisabled(item)\" type=\"button\" icon=\"p-button-icon pi pi-trash\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_supprimer\"\r\n              styleClass=\"p-element p-button-rounded p-button-text p-button-danger p-button p-component p-button-icon-only\"\r\n              (click)=\"delete(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n\r\n        <td class=\"ui-resizable-column\" pFrozenColumn [frozen]=\"col.isFrozen\" *ngFor=\"let col of columns\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\"\r\n          [ngStyle]=\"getBodyColumnStyle(col)\">\r\n          \r\n          \r\n          <div *ngIf=\"col.displayOnly || disabled; else ordinaryBloc\">\r\n\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteOutputBlock\">\r\n                  <Tsi-Search-Combo [disabled]=\"true\" [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [businessClass]=\"col.businessClass\" [currentRowItem]=\"item\" [(bind)]=\"item[col.field]\"\r\n                    id-field=\"{{col.idField}}\" [listSourceUrl]=\"col.listSourceUrl\" label-field=\"{{col.labelField}}\"\r\n                    [isFiltered]=\"col.isFiltered\" [datasource]=\"col.datasource\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Display -->\r\n                <ng-template #currencySocieteOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n                    <Tsi-Currency-Societe-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Societe-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Display -->\r\n                <ng-template #currencyOtherOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerOutputBlock\">\r\n                    <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Other-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Display -->\r\n                <ng-template #datePickerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxOutputBlock\">\r\n                    <Tsi-Date-Display [showTime]=\"col.showTime\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Date-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox-Display -->\r\n                <ng-template #checkBoxOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalOutputBlock\">\r\n                    <Tsi-Checkbox-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Checkbox-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Display -->\r\n                <ng-template #decimalOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                    <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"item[col.field]\"\r\n                      [numOfDecimal]=\"col.numOfDecimal\">\r\n                    </Tsi-Decimal-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer-Display -->\r\n                <ng-template #integerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                    <Tsi-Integer-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Integer-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Display -->\r\n                <ng-template #rateOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeOutputBlock\">\r\n                    <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Rate-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Display -->\r\n                <ng-template #timeOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaOutputBlock\">\r\n                    <tsi-time-display [inputData]=\"item[col.field]\"></tsi-time-display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Formula-Display -->\r\n                <ng-template #formulaOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextOutputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextOutputBlock>\r\n                  <ng-container>\r\n                    <span>\r\n                      {{item[col.field]}}\r\n                    </span>\r\n                  </ng-container>\r\n                </ng-template>\r\n          </div>\r\n\r\n          <ng-template #ordinaryBloc>\r\n\r\n            <!-- Tsi-Search-Combo -->\r\n            <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteInputBlock\">\r\n              <Tsi-Search-Combo [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                [businessClass]=\"col.businessClass\" [listSourceUrl]=\"col.listSourceUrl\" [(bind)]=\"item[col.field]\"\r\n                id-field=\"{{col.idField}}\" label-field=\"{{col.labelField}}\" [isFiltered]=\"col.isFiltered\"\r\n                [currentRowItem]=\"item\" (bindChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                [datasource]=\"col.datasource\" [showSearchButton]=\"col.showSearchButton ?? true\"\r\n                [showAddButton]=\"col.showAddButton ?? true\" [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n            </div>\r\n\r\n            <!-- Tsi-Currency-Societe-Input -->\r\n            <ng-template #currencySocieteInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherInputBlock\">\r\n                <Tsi-Currency-Societe-Input [inputName]=\"col.inputName\" [disabled]=\"col.disabled\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Currency-Societe-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Currency-Other-Input -->\r\n            <ng-template #currencyOtherInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerInputBlock\">\r\n                <Tsi-Currency-Other-Input [inputName]=\"col.inputName\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [currency]=\"col.currencyOtherCode\" [disabled]=\"col.disabled\">\r\n                </Tsi-Currency-Other-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Date-Picker -->\r\n            <ng-template #datePickerInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxInputBlock\">\r\n                <Tsi-Date-Picker [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [showTime]=\"col.showTime\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Date-Picker>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-CheckBox -->\r\n            <ng-template #checkBoxInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalInputBlock\">\r\n                <Tsi-CheckBox [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\" \r\n                  [isBinary]=\"col.isBinary ?? false\">\r\n                </Tsi-CheckBox>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Decimal-Input -->\r\n            <ng-template #decimalInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerInputBlock\">\r\n                <Tsi-Decimal-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [numOfDecimal]=\"col.numOfDecimal\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Decimal-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Integer -->\r\n            <ng-template #integerInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateInputBlock\">\r\n                <Tsi-Integer [inputName]=\"col.inputName\" [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                  [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                </Tsi-Integer>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Rate-Input -->\r\n            <ng-template #rateInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeInputBloc\">\r\n                <Tsi-Rate-Input [inputName]=\"col.inputName\" [numOfDecimal]=\"col.numOfDecimal\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Rate-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Time-picker bloc -->\r\n            <ng-template #timeInputBloc>\r\n              <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaInputBlock\">\r\n                <tsi-time-picker (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [inputName]=\"col.inputName\"\r\n                  [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\" [disabled]=\"col.disabled\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </tsi-time-picker>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <ng-template #formulaInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextInputBlock\">\r\n                <!--<Tsi-Bubble-Info\r\n                  [infoText]=\"['formula_explication',\r\n                  ]\"></Tsi-Bubble-Info> -->\r\n                <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Text-Box -->\r\n            <ng-template #defaultTextInputBlock>\r\n              <ng-container>\r\n                <Tsi-Text-Box [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\" (keydown)=\"handleKeydown($event)\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                  [inputName]=\"col.inputName\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Text-Box>\r\n              \r\n              </ng-container>\r\n            </ng-template>\r\n          </ng-template>\r\n\r\n        </td>\r\n\r\n        <td *ngIf=\"showRowSummary\" class=\"font-bold\">\r\n          {{rowSummary(item)}}\r\n        </td>\r\n      </tr>\r\n\r\n      <ng-template #selectionModeBlock>\r\n        <ng-container>\r\n          <tr [pEditableRow]=\"item\" [pSelectableRow]=\"item\" [pSelectableRowIndex]=\"rowIndex\"\r\n            (focusOut)=\"onFocusOutRow(item)\">\r\n\r\n       <!-- <td pFrozenColumn style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\"> -->\r\n\r\n            <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              </td>\r\n\r\n            <!-- <td *ngIf=\"selectionMode == multipleGridSelectionMode\" style=\"width: 2rem;\">\r\n              <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n            </td> -->\r\n\r\n            <!-- <td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem;left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              <div class=\"flex align-items-center justify-content-center\">\r\n                <button *ngIf=\"!editing\" pButton pRipple type=\"button\" pInitEditableRow icon=\"pi pi-pencil\"\r\n                  class=\"p-button-rounded p-button-text\">\r\n                </button>\r\n                <button *ngIf=\"editing\" pButton pRipple type=\"button\" pSaveEditableRow icon=\"pi pi-check\"\r\n                  class=\"p-button-rounded p-button-text p-button-success -ml-1\">\r\n                </button>\r\n                <button *ngIf=\"editing\" pButton pRipple type=\"button\" pCancelEditableRow icon=\"pi pi-times\"\r\n                  class=\"p-button-rounded p-button-text p-button-danger -ml-2\">\r\n                </button>\r\n              </div>\r\n            </td> -->\r\n            \r\n            <td pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\">\r\n            </td>\r\n            \r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showDuplicateButton\"\r\n              style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-copy\"\r\n                  [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_dupliquer\"\r\n                  styleClass=\"p-button-rounded p-button-text p-button-info\" (click)=\"duplicateRow(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n\r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showConsultButton\"\r\n              style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1 btn-consult-style\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-eye\"\r\n                  [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_consulter\"\r\n                  styleClass=\"p-button-rounded p-button-text p-button-secondary\" (click)=\"consult(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n\r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showDeleteButton\" style=\"left: 1rem !important; width:3rem !important;\"\r\n              class=\"p-1 btn-delete-style\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button type=\"button\" icon=\"p-button-icon pi pi-trash\" [tooltipPosition]=\"tooltipPosition.Top\"\r\n                  tooltipText=\"shared_edittable_supprimer\"\r\n                  styleClass=\"p-element p-button-rounded p-button-text p-button-danger p-button p-component p-button-icon-only\"\r\n                  (click)=\"delete(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n            \r\n            <td class=\"ui-resizable-column\" pFrozenColumn [frozen]=\"col.isFrozen\" *ngFor=\"let col of columns\"\r\n              [class.tsi-col-wrap]=\"shouldWrapColumn(col)\" [ngStyle]=\"getBodyColumnStyle(col)\">\r\n\r\n              <div *ngIf=\"col.displayOnly || disabled; else ordinaryBloc\">\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteOutputBlock\">\r\n                  <Tsi-Search-Combo [disabled]=\"true\" [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [businessClass]=\"col.businessClass\" [currentRowItem]=\"item\" [(bind)]=\"item[col.field]\"\r\n                    id-field=\"{{col.idField}}\" [listSourceUrl]=\"col.listSourceUrl\" label-field=\"{{col.labelField}}\"\r\n                    [isFiltered]=\"col.isFiltered\" [datasource]=\"col.datasource\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Display -->\r\n                <ng-template #currencySocieteOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n                    <Tsi-Currency-Societe-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Societe-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Display -->\r\n                <ng-template #currencyOtherOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerOutputBlock\">\r\n                    <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Other-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Display -->\r\n                <ng-template #datePickerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxOutputBlock\">\r\n                    <Tsi-Date-Display [showTime]=\"col.showTime\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Date-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox-Display -->\r\n                <ng-template #checkBoxOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalOutputBlock\">\r\n                    <Tsi-Checkbox-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Checkbox-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Display -->\r\n                <ng-template #decimalOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                    <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"item[col.field]\"\r\n                      [numOfDecimal]=\"col.numOfDecimal\">\r\n                    </Tsi-Decimal-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer-Display -->\r\n                <ng-template #integerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                    <Tsi-Integer-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Integer-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Display -->\r\n                <ng-template #rateOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeOutputBlock\">\r\n                    <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Rate-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Display -->\r\n                <ng-template #timeOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaOutputBlock\">\r\n                    <tsi-time-display [inputData]=\"item[col.field]\"></tsi-time-display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Formula-Display -->\r\n                <ng-template #formulaOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextOutputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextOutputBlock>\r\n                  <ng-container>\r\n                    <span>\r\n                      {{item[col.field]}}\r\n                    </span>\r\n                  </ng-container>\r\n                </ng-template>\r\n              </div>\r\n              \r\n              <ng-template #ordinaryBloc>\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteInputBlock\">\r\n                  <Tsi-Search-Combo [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [listSourceUrl]=\"col.listSourceUrl\" [(bind)]=\"item[col.field]\" id-field=\"{{col.idField}}\"\r\n                    label-field=\"{{col.labelField}}\" [isFiltered]=\"col.isFiltered\" [businessClass]=\"col.businessClass\"\r\n                    (bindChange)=\"onCellValueChanged(col, $event, item)\" [currentRowItem]=\"item\"\r\n                    [datasource]=\"col.datasource\" [disabled]=\"col.disabled\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Input -->\r\n                <ng-template #currencySocieteInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherInputBlock\">\r\n                    <Tsi-Currency-Societe-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Currency-Societe-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Input -->\r\n                <ng-template #currencyOtherInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerInputBlock\">\r\n                    <Tsi-Currency-Other-Input [disabled]=\"col.disabled\" [inputName]=\"col.inputName\"\r\n                      [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\" [currency]=\"col.currencyOtherCode\">\r\n                    </Tsi-Currency-Other-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Picker -->\r\n                <ng-template #datePickerInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxInputBlock\">\r\n                    <Tsi-Date-Picker [showTime]=\"col.showTime\" [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Date-Picker>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox -->\r\n                <ng-template #checkBoxInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalInputBlock\">\r\n                    <Tsi-CheckBox [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      [isBinary]=\"col.isBinary ?? false\">\r\n                    </Tsi-CheckBox>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Input -->\r\n                <ng-template #decimalInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerInputBlock\">\r\n                    <Tsi-Decimal-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      [(inputField)]=\"item[col.field]\" [numOfDecimal]=\"col.numOfDecimal\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                    </Tsi-Decimal-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer -->\r\n                <ng-template #integerInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateInputBlock\">\r\n                    <Tsi-Integer [class]=\"'max-w-4rem'\" [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                    </Tsi-Integer>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Input -->\r\n                <ng-template #rateInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeInputBloc\">\r\n                    <Tsi-Rate-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Rate-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Picker -->\r\n                <ng-template #timeInputBloc>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME else formulaInputBlock\">\r\n                    <tsi-time-picker (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                      [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                      [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </tsi-time-picker>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <ng-template #formulaInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextInputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextInputBlock>\r\n                  <ng-container>\r\n                    <Tsi-Text-Box [inputId]=\"col.field\" [disabled]=\"col.disabled\"\r\n                      [(inputField)]=\"item[col.field]\" (keydown)=\"handleKeydown($event)\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [inputName]=\"col.inputName\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Text-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n              </ng-template>\r\n\r\n            </td>\r\n            <td *ngIf=\"showRowSummary\" class=\"font-bold\">\r\n              {{rowSummary(item)}}\r\n            </td>\r\n          </tr>\r\n        </ng-container>\r\n      </ng-template>\r\n\r\n    </ng-template>\r\n\r\n    <ng-template *ngIf=\"showHaveSumary\" pTemplate=\"footer\" let-columns>\r\n\r\n      <tr class=\"tfooter\">\r\n        <!-- <td pFrozenColumn scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\"></td> -->\r\n        <td *ngIf=\"selectionMode == multipleGridSelectionMode\"\r\n          style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\">\r\n          <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n        </td>\r\n        <td pFrozenColumn scope=\"col\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\">Total</td>\r\n        <td pFrozenColumn *ngIf=\"showDeleteButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\">\r\n        <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n          <!--<td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\"> -->\r\n        <td pFrozenColumn *ngIf=\"showDuplicateButton\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td>\r\n        <td pFrozenColumn *ngIf=\"showConsultButton\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td>\r\n        <td pFrozenColumn [frozen]=\"col.isFrozen\" [style]=\"col.style\" [ngStyle]=\"getColumnSizeStyle(col)\" scope=\"col\" *ngFor=\"let col of columns\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\">\r\n          <div *ngIf=\"col.haveSummary\">\r\n            <!-- Tsi-Currency-Societe-Display -->\r\n            <div *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n              <Tsi-Currency-Societe-Display [inputData]=\"getSummary(col)\">\r\n              </Tsi-Currency-Societe-Display>\r\n            </div>\r\n\r\n            <!-- Tsi-Currency-Other-Display -->\r\n            <ng-template #currencyOtherOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else decimalOutputBlock\">\r\n                <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"getSummary(col)\">\r\n                </Tsi-Currency-Other-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Decimal-Display -->\r\n            <ng-template #decimalOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"getSummary(col)\"\r\n                  [numOfDecimal]=\"col.numOfDecimal\">\r\n                </Tsi-Decimal-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Integer-Display -->\r\n            <ng-template #integerOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                <Tsi-Integer-Display [inputData]=\"getSummary(col)\">\r\n                </Tsi-Integer-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Rate-Display -->\r\n            <ng-template #rateOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else defaultTextOutputBlock\">\r\n                <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"getSummary(col)\">\r\n                </Tsi-Rate-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Default -->\r\n            <ng-template #defaultTextOutputBlock>\r\n              <ng-container>\r\n                <span>\r\n                  {{getSummary(col)}}\r\n                </span>\r\n              </ng-container>\r\n            </ng-template>\r\n          </div>\r\n        </td>\r\n      </tr>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"summary\">\r\n      <tr>\r\n        {{'TotalRecordsCount' | localize }} {{gridData.length}}\r\n      </tr>\r\n    </ng-template>\r\n  </p-table>\r\n  <div>\r\n    <Tsi-Button *ngIf=\"showAddButton\" style=\"height: 20px;width: 20px;\" icon=\"p-button-icon pi pi-plus\" type=\"button\"\r\n      [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_ajouter\"\r\n      styleClass=\"p-element p-button-sm p-button-success p-button-text p-button p-component p-button-icon-only ng-star-inserted\"\r\n      (click)=\"addRow()\"></Tsi-Button>\r\n  </div>\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable-grid.component.js","sourceRoot":"","sources":["../../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/input-components/editable-grid/editable-grid.component.ts","../../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/input-components/editable-grid/editable-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, HostListener, inject, Input, OnDestroy, OnInit, Output, ViewChild } from '@angular/core';\r\nimport { FilterService, SortEvent, TableState } from 'primeng/api';\r\nimport { Table, TableRowSelectEvent, TableRowUnSelectEvent } from 'primeng/table';\r\nimport { Observable, Subscription } from 'rxjs';\r\nimport { rtlModeKeys } from '../../../consts/locals.const';\r\nimport { ButtonType, GridSelectionMode, InputTypes, ModalSizeEnum, TooltipPosition } from '../../../enums';\r\nimport { preciseAdd, preciseSum } from '../../../functions';\r\nimport { CellChangedResult, GridColumn, IGridConfiguration, RowAddedResult } from '../../../interfaces';\r\nimport { LocalizePipe } from '../../../pipes/localize.pipe';\r\nimport { CollectionChangeAction, CollectionChangedEvent, ObservableCollection } from '../../../models/collection/observable-collection';\r\nimport { EntityValidationsService } from '../../../services/validation/entity-validations.service';\r\nimport { GenericValidationStateService } from '../../../services';\r\nimport { FormState } from '../../../models/form/form-state';\r\nimport { TsiInputBase } from '../../../tsi-base/tsi-input-base/tsi-input-base.component';\r\nimport { ColumnWidthController } from '../../../tsi-helpers/column-width.controller';\r\nimport { GridSizingMode } from '../../../enums/grid-sizing-mode';\r\nimport { LayoutHelperService } from '../../../services/layout/layout-helper.service';\r\n\r\n@Component({\r\n  selector: 'Tsi-Generic-Editable-Grid',\r\n  templateUrl: './editable-grid.component.html',\r\n  styleUrls: ['./editable-grid.component.scss'],\r\n  providers: [GenericValidationStateService]\r\n})\r\nexport class EditableGridComponent extends TsiInputBase implements OnInit, OnDestroy {\r\n\r\n  //#region local vars\r\n  //#region private local vars\r\n  private saveEventSubscription?: Subscription;\r\n  private _isAutoRowNumber: boolean = false;\r\n  private _autoRowNumberField: string = '';\r\n  private _currentRowNumber: number = 0;\r\n  tooltipPosition = TooltipPosition;\r\n  isAr: boolean = false;\r\n  private _gridData: Array<any> = [];\r\n  private _equatableFields: Array<string> | undefined;\r\n  private _sumAtFusionFields: Array<string> | undefined;\r\n  private _equalityCheckOn: boolean = false;\r\n  private _f6SourceRow: any = null;\r\n  private _pendingDuplicateEmitTimer: ReturnType<typeof setTimeout> | null = null;\r\n  private _pendingDuplicateResult: RowAddedResult | null = null;\r\n  private static readonly SEARCH_LABEL_PREFIX = '__search_label__';\r\n\r\n  /**\r\n   * Name of the custom PrimeNG filter registered for global search.\r\n   * Extends the built-in 'contains' with locale-aware decimal matching\r\n   * (comma vs dot separator) while keeping full protection against false\r\n   * positives on text columns.\r\n   * @see _registerGridContainsFilter\r\n   */\r\n  private static readonly DECIMAL_AWARE_CONTAINS_FILTER = 'grid-contains';\r\n  multipleGridSelectionMode = GridSelectionMode.Multiple;\r\n  searchValue: string = '';\r\n  globalFilterFields: string[] = [];\r\n  //#endregion\r\n  inputTypes = InputTypes;\r\n  modalSize = ModalSizeEnum.ExtraLarge;\r\n  @ViewChild(\"editableTable\") editableTable?: Table\r\n\r\n  buttonType = ButtonType;\r\n\r\n  @Input() selectedItems: any = [];\r\n  selectedItem: any;\r\n\r\n  //#endregion\r\n\r\n  //#region Inputs\r\n  @Input('configuration') configuration?: IGridConfiguration;\r\n  @Input('key') key: string = 'uid';\r\n  @Input() items: Array<any> = [];\r\n  @Input() saveEvent?: Observable<void>;\r\n  /**\r\n   * Controls the visibility of the global search bar in the grid caption.\r\n   *\r\n   * When `true`, a search input and button are displayed, allowing users to\r\n   * filter rows across all visible columns simultaneously. Supports plain text,\r\n   * dropdown labels (resolved via shadow fields), and decimal values with\r\n   * locale-aware comma/dot matching.\r\n   *\r\n   * Defaults to `false` to preserve the existing behaviour for all consumers\r\n   * that do not explicitly opt in — enabling it on a specific grid is as simple\r\n   * as adding `[showGlobalSearch]=\"true\"`.\r\n   */\r\n  @Input() showGlobalSearch: boolean = false;\r\n\r\n  @Input() showAddButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showDeleteButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showEditButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showRowSummary: boolean = false;//TO DO Save Button Option\r\n\r\n  @Input() scrollHeight: string = '500px';\r\n\r\n  /**\r\n   * Fill (default): the table stretches to fill its container. Hug: the table shrinks to\r\n   * its columns' size (never wider than the container), leaving leftover width empty.\r\n   */\r\n  @Input() sizingMode: GridSizingMode = GridSizingMode.Fill;\r\n\r\n  /**\r\n   * Sizing style bound to the p-table's `[tableStyle]` — the single lever that distinguishes\r\n   * Fill from Hug (see GridSizingMode). Applied inline on the PrimeNG table, so it beats\r\n   * PrimeNG's default `.p-datatable-table { width: 100% }` with no `!important`/`::ng-deep`.\r\n   * - Fill: default (no forced width; PrimeNG fills the container).\r\n   * - Hug: `width:auto` shrinks the table to its columns; `max-width:100%` keeps it inside the\r\n   *   page (overflow scrolls); `min-width:0` avoids any inherited floor.\r\n   *\r\n   * Hug + `columnResizeMode=\"expand\"`: dragging a column resizes that column, but `width:auto`\r\n   * is re-asserted on change detection, so the table itself stays hugged and never expands.\r\n   */\r\n  get tableStyle(): { [key: string]: string } {\r\n    return this.sizingMode === GridSizingMode.Hug\r\n      ? { 'width': 'auto', 'min-width': '0', 'max-width': '100%' }\r\n      : {};\r\n  }\r\n  @Input() rowPerPage: number[] = [5, 10, 20];\r\n  // @Input() isPaginator: boolean = true;\r\n  @Input() pageSize: number = 5\r\n  @Input() entityPrimaryKeyName : string = 'uid'\r\n\r\n  private _selectedColumns: Array<GridColumn> = [];\r\n\r\n  get selectedColumns(): Array<GridColumn> {\r\n    return this._selectedColumns;\r\n  }\r\n\r\n  set selectedColumns(value: Array<GridColumn>) {\r\n    this._selectedColumns = value;\r\n    this._syncGlobalFilterFields();\r\n  }\r\n\r\n  private _columns: Array<GridColumn> = [];\r\n  private _tempColumns: Array<GridColumn> = [];\r\n  private _columnsChangedSubscription?: Subscription;\r\n\r\n  get columns(): Array<GridColumn> {\r\n    return this._columns;\r\n  }\r\n\r\n  @Input() set columns(value: Array<GridColumn> | ObservableCollection<GridColumn>) {\r\n    this._columnsChangedSubscription?.unsubscribe();\r\n\r\n    const isObservable = (value as ObservableCollection<GridColumn>).isObservableCollection === true;\r\n    const items = isObservable ? (value as ObservableCollection<GridColumn>).toArray() : value as Array<GridColumn>;\r\n    items.forEach(el => el.translatedHeader = this._localizePipe.transform(el.header ?? \"\"));\r\n    this._columns = items;\r\n    this.selectedColumns = [...items];\r\n\r\n    if (isObservable) {\r\n      this._columnsChangedSubscription = (value as ObservableCollection<GridColumn>).changed.subscribe(event => {\r\n        console.log(\"event changed => \", event)\r\n        this._onColumnsChanged(event)\r\n      });\r\n    }\r\n\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n  @Input() set gridData(data: Array<any>) {\r\n    this._gridData = data;\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n  get gridData() { return this._gridData; }\r\n\r\n  @Input() isTableLoading?: boolean;\r\n\r\n\r\n  @Input() parent: any;\r\n\r\n  @Input() showSaveButton: boolean = true;//TO DO Save Button Option\r\n  @Input() showActionColumn: boolean = true;//TO DO Save Button Option\r\n\r\n\r\n  @Input() enableRowDisabling: boolean = false;\r\n\r\n  @Input() rowSummaryConfig: Array<string> = [];\r\n  @Input() showHaveSumary?: boolean = false;\r\n  @Input() showRowSumary?: boolean = false;\r\n\r\n  /**selection */\r\n  @Input() selectKeyOnly: boolean = true;\r\n  @Input() selectionMode: GridSelectionMode | any = GridSelectionMode.Single;\r\n  @Input() showConsultButton: boolean = false;\r\n\r\n  private _editableGridBusinessClass: string = \"\";\r\n  get editableGridBusinessClass() {\r\n    return this._editableGridBusinessClass;\r\n  }\r\n  @Input() set editableGridBusinessClass(className: string) {\r\n    this._editableGridBusinessClass = className;\r\n    this.genericValidationStateService?.loadEntityValidationInfos(this._editableGridBusinessClass);\r\n  }\r\n\r\n\r\n  /**order */\r\n  @Input() orderColumn: string = 'uid';\r\n\r\n  @Input() deleteLineButtonDisabled!: (item: any) => any\r\n\r\n  @Input() showDuplicateButton: boolean = true;\r\n\r\n  //#endregion\r\n\r\n  //#region Outputs\r\n\r\n  @Output() refreshEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  //@Output() actionEventEmitter: EventEmitter<GridActionEmitResult> = new EventEmitter<GridActionEmitResult>();\r\n\r\n  @Output() saveDataEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() rowChangedEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() selectedRowEventEmitter: EventEmitter<any> = new EventEmitter();\r\n\r\n  @Output() addedRowEventEmitter: EventEmitter<RowAddedResult> = new EventEmitter<RowAddedResult>()\r\n\r\n  @Output() focusOutEventEmitter = new EventEmitter<string>();\r\n\r\n  @Output() cellChanged: EventEmitter<CellChangedResult> = new EventEmitter<CellChangedResult>();\r\n\r\n  @Output() rowDeletedEventEmitter = new EventEmitter<any>();\r\n\r\n  @Output() selectedItemsChange: EventEmitter<Array<any>> = new EventEmitter<Array<any>>();\r\n\r\n  @Output() onRowSelect: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() focusOutRow: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() onConsultClicked: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() rowDuplicatedEventEmitter: EventEmitter<RowAddedResult> = new EventEmitter<RowAddedResult>();\r\n  //#endregion\r\n\r\n  @ViewChild(\"dt\", { static: false }) public dt: Table | undefined;\r\n\r\n  @Input() id?: string;\r\n\r\n  /**\r\n   * Tracks rows by their business key (`key` input) so PrimeNG reuses existing row views\r\n   * instead of destroying/recreating them when the row array is replaced with objects sharing\r\n   * the same key (e.g. after a recalculation that clones the data). Without this, every cell\r\n   * editor — including server-backed search combos — is re-instantiated and re-fetches its data.\r\n   * Falls back to the row index when the key is absent (e.g. brand-new rows).\r\n   * Arrow property so `this` is preserved when PrimeNG invokes it.\r\n   */\r\n  rowTrackBy = (index: number, item: any): any => item?.[this.key] ?? index;\r\n\r\n  private _entityValidationsService = inject(EntityValidationsService);\r\n  private _stripedRowsLayoutHelperService = inject(LayoutHelperService);\r\n\r\n  constructor(private _localizePipe: LocalizePipe, private _filterService: FilterService) {\r\n    super();\r\n    this._registerGridContainsFilter();\r\n  }\r\n\r\n  get stripedRows(): boolean {\r\n    return this._stripedRowsLayoutHelperService.layoutConfiguration.isStripedRowsEnabled;\r\n  }\r\n\r\n  override ngOnInit() {\r\n    super.ngOnInit()\r\n    this._initSaveEventSubscription();\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n    this._initEquatableFields();\r\n    this._initSumAtFusionFields();\r\n    \r\n    let langue = localStorage.getItem(rtlModeKeys.rtlModeEnabled);\r\n    \r\n    if (langue && JSON.parse(langue)) {\r\n      this.isAr = true\r\n    }\r\n    else {\r\n      this.isAr = false\r\n    }\r\n\r\n    if (!this.selectedColumns || this.selectedColumns.length == 0) {\r\n      this.selectedColumns = this.columns\r\n    }\r\n\r\n    this._tempColumns = this.columns;\r\n  }\r\n\r\n  findColumnByKey(key: any) {\r\n    if (this.columns) {\r\n      for (let col of this.columns) {\r\n        if (col.header === key || col.field === key) return col;\r\n        else continue;\r\n      }\r\n    }\r\n    return null\r\n  }\r\n\r\n\r\n  public restoreState(configuration: string) {\r\n    let state: TableState = JSON.parse(configuration)\r\n    if (this.dt) {\r\n      this.columnWidth.setRemembered(state.columnWidths);\r\n      this.dt.columnWidthsState = state.columnWidths;\r\n      this.dt.tableWidthState = state.tableWidth;\r\n\r\n      let columnOrder = state.columnOrder;\r\n\r\n      if (columnOrder) {\r\n        let reorderedColumns = this.getReorderedColumns(columnOrder);\r\n        if (reorderedColumns.length > 0) {\r\n          this.selectedColumns = reorderedColumns;\r\n        }\r\n      }\r\n\r\n      // Apply the remembered column widths to the DOM. Assigning columnWidthsState\r\n      // alone is a no-op here because the grid is not PrimeNG-\"stateful\" (no stateKey).\r\n      this.dt.restoreColumnWidths();\r\n    }\r\n  }\r\n\r\n  getReorderedColumns(columnOrder: string[]): any[] {\r\n    let reorderedColumns: any[] = [];\r\n\r\n    columnOrder.map((key) => {\r\n      let col = this.findColumnByKey(key);\r\n      if (col) {\r\n        reorderedColumns.push(col);\r\n      }\r\n    });\r\n\r\n    return reorderedColumns;\r\n  }\r\n\r\n  resetSelectedColumns(configuration: string) {\r\n    let state: TableState = JSON.parse(configuration)\r\n    if (this.dt) {\r\n      this.columnWidth.reset();\r\n      this.columnWidth.setRemembered(state.columnWidths);\r\n      this.dt.columnWidthsState = state.columnWidths;\r\n      this.dt.tableWidthState = state.tableWidth;\r\n\r\n      let columnOrder = state.columnOrder;\r\n\r\n      if (columnOrder) {\r\n        let reorderedColumns = this.getReorderedColumns(columnOrder);\r\n        this.selectedColumns = reorderedColumns.length > 0 ? reorderedColumns : [...this._columns];\r\n      }\r\n\r\n      this.dt.restoreColumnWidths();\r\n    }\r\n  }\r\n\r\n  getState() {\r\n    let state: TableState = {};\r\n\r\n    if (!this.dt) {\r\n      return\r\n    }\r\n\r\n    if (this.dt.resizableColumns) {\r\n      this.dt.saveColumnWidths(state);\r\n    }\r\n\r\n    this.dt.saveColumnOrder(state);\r\n\r\n    return state\r\n  }\r\n\r\n  /**\r\n   * Shared model for the developer-width / wrapping / resize-priority behavior. Action/button\r\n   * columns and frozen columns are excluded (frozen columns must keep their sticky-offset\r\n   * width or later frozen columns misalign); all other columns are eligible.\r\n   */\r\n  private readonly columnWidth = new ColumnWidthController((col) => !col.isButton && !col.isFrozen);\r\n\r\n  /** Remember which column the user resized so its developer-preferred width yields. */\r\n  onColResize(event: { element?: HTMLElement; delta?: number }): void {\r\n    this.columnWidth.onResize(event?.element?.getAttribute('data-field'));\r\n  }\r\n\r\n  /** Whether a column's content should wrap to stay inside its constrained width. */\r\n  shouldWrapColumn(col: GridColumn): boolean {\r\n    return this.columnWidth.shouldWrap(col);\r\n  }\r\n\r\n  /**\r\n   * Developer size style only, bound via `[ngStyle]` on the header/summary cells alongside\r\n   * their untouched `[style]=\"col.style\"` (so a string `col.style` is never spread/broken).\r\n   */\r\n  getColumnSizeStyle(col: GridColumn): { [key: string]: string } {\r\n    return this.columnWidth.sizeStyle(col);\r\n  }\r\n\r\n  /** Body `<td>` style: RTL alignment + top-align (eligible cells) + developer size style. */\r\n  getBodyColumnStyle(col: GridColumn): { [key: string]: any } {\r\n    const base = this.isAr ? { 'text-align': 'start' } : {};\r\n    return { ...base, ...this.columnWidth.verticalAlign(col), ...this.columnWidth.sizeStyle(col) };\r\n  }\r\n\r\n  isDeleteButtonDisabled(item: any) {\r\n    if (this.deleteLineButtonDisabled != undefined) {\r\n      return this.deleteLineButtonDisabled(item)\r\n    }\r\n  }\r\n\r\n  override ngOnDestroy(): void {\r\n    super.ngOnDestroy()\r\n    this.saveEventSubscription?.unsubscribe();\r\n    this._cancelPendingDuplicateEmit();\r\n    this._columnsChangedSubscription?.unsubscribe();\r\n  }\r\n\r\n  private _onColumnsChanged(event: CollectionChangedEvent<GridColumn>): void {\r\n    switch (event.action) {\r\n      case CollectionChangeAction.Add: {\r\n        if (event.newItems && event.newStartingIndex !== undefined) {\r\n          event.newItems.forEach(col =>\r\n            col.translatedHeader = this._localizePipe.transform(col.header ?? \"\")\r\n          );\r\n          const prevSelected = new Set(this.selectedColumns);\r\n          const newColumns = [...this._columns];\r\n          newColumns.splice(event.newStartingIndex, 0, ...event.newItems);\r\n          this._columns = newColumns;\r\n          this.selectedColumns = this._columns.filter(\r\n            c => prevSelected.has(c) || event.newItems!.includes(c)\r\n          );\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Remove: {\r\n        if (event.oldItems) {\r\n          const removed = new Set(event.oldItems);\r\n          this._columns = this._columns.filter(c => !removed.has(c));\r\n          this.selectedColumns = this.selectedColumns.filter(c => !removed.has(c));\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Replace: {\r\n        if (event.newItems && event.oldItems && event.newStartingIndex !== undefined) {\r\n          event.newItems.forEach(col =>\r\n            col.translatedHeader = this._localizePipe.transform(col.header ?? \"\")\r\n          );\r\n          const prevSelected = new Set(this.selectedColumns);\r\n          const removedOld = new Set(event.oldItems);\r\n          const newColumns = [...this._columns];\r\n          newColumns.splice(event.newStartingIndex, event.oldItems.length, ...event.newItems);\r\n          this._columns = newColumns;\r\n          this.selectedColumns = this._columns.filter(\r\n            c => (prevSelected.has(c) && !removedOld.has(c)) || event.newItems!.includes(c)\r\n          );\r\n        }\r\n        break;\r\n      }\r\n      case CollectionChangeAction.Reset:\r\n      default: {\r\n        this._columns = [];\r\n        this.selectedColumns = [];\r\n        break;\r\n      }\r\n    }\r\n\r\n    this._verifyGridRequirements();\r\n    this._initCurrentRowNumberAndOrderByRowNumber();\r\n  }\r\n\r\n  saveItems() {\r\n    const clean = this._cleanGridDataForEmit();\r\n    this.saveDataEventEmitter.emit(clean);\r\n  }\r\n\r\n  addRow(): void {\r\n    if (!this.gridData) {\r\n      this.gridData = [];\r\n    }\r\n    let newRow = this._initRow()\r\n    this.gridData.push(newRow)\r\n    this.isDirty = true\r\n    let rowAddedResult: RowAddedResult = {\r\n      rowNumber: this.gridData.length - 1,\r\n      data: newRow\r\n    }\r\n\r\n    if (this.editableTable?.sortField && this.editableTable.sortOrder) {\r\n      this.editableTable?.value.push(newRow)\r\n    }\r\n    this.refreshSort()\r\n    this.addedRowEventEmitter.emit(rowAddedResult)\r\n  }\r\n\r\n  duplicateRow(item: any, updateSelection: boolean = true, skipEmit: boolean = false): RowAddedResult | null {\r\n    if (!item) return null;\r\n\r\n    const duplicatedRow = JSON.parse(JSON.stringify(item));\r\n    duplicatedRow[this.entityPrimaryKeyName] = undefined;\r\n    \r\n    for (const col of this.columns) {\r\n      if (col.excludeOnDuplicate && Object.prototype.hasOwnProperty.call(duplicatedRow, col.field)) {\r\n        duplicatedRow[col.field] = undefined;\r\n      }\r\n    }\r\n\r\n    if (this._isAutoRowNumber) {\r\n      duplicatedRow[this._autoRowNumberField] = this._nextRowNumber();\r\n    }\r\n\r\n    if (this.editableTable?.sortField && this.editableTable.sortOrder) {\r\n      const tableIndex = this.editableTable.value.indexOf(item, 0);\r\n      if (tableIndex > -1) {\r\n        this.editableTable.value.splice(tableIndex + 1, 0, duplicatedRow);\r\n      } else {\r\n        this.editableTable.value.push(duplicatedRow);\r\n      }\r\n    }\r\n\r\n    const dataIndex = this.gridData.indexOf(item, 0);\r\n    if (dataIndex > -1) {\r\n      this.gridData.splice(dataIndex + 1, 0, duplicatedRow);\r\n    } else {\r\n      this.gridData.push(duplicatedRow);\r\n    }\r\n    this.isDirty = true;\r\n\r\n    this.refreshSort();\r\n\r\n    if (updateSelection) {\r\n      this.selectedItem = duplicatedRow;\r\n      this.selectedItems = this.selectionMode == GridSelectionMode.Multiple\r\n        ? [duplicatedRow]\r\n        : duplicatedRow;\r\n    }\r\n\r\n    const result: RowAddedResult = {\r\n      rowNumber: this.gridData.indexOf(duplicatedRow),\r\n      data: duplicatedRow\r\n    };\r\n\r\n    if (!skipEmit) {\r\n      this.addedRowEventEmitter.emit(result);\r\n      this.rowDuplicatedEventEmitter.emit(result);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  refreshSort() {\r\n    if (this.editableTable?.sortField) {\r\n      const sortField = this.editableTable.sortField;\r\n      const sortOrder = this.editableTable.sortOrder;\r\n\r\n      this.gridData.sort((a, b) => {\r\n        const valueA = a[sortField];\r\n        const valueB = b[sortField];\r\n        let result = 0;\r\n\r\n        if (valueA < valueB) result = -1;\r\n        else if (valueA > valueB) result = 1;\r\n\r\n        return result * sortOrder;\r\n      });\r\n\r\n      this.gridData = [...this.gridData];\r\n    }\r\n  }\r\n\r\n  delete(item: any) {\r\n    if (this.editableTable?.sortField && this.editableTable.sortMode) {\r\n      const index = this.editableTable.value.indexOf(item, 0);\r\n      if (index > -1) {\r\n        this.editableTable.value.splice(index, 1)\r\n      }\r\n    }\r\n    const index = this.gridData.indexOf(item, 0);\r\n    if (index > -1) {\r\n      this.gridData.splice(index, 1);\r\n      this.isDirty = true\r\n      this._onDeleteRow(item);\r\n      this.rowDeletedEventEmitter.emit(this._cleanGridDataForEmit())\r\n    }\r\n    this.refreshSort()\r\n  }\r\n\r\n  getSummary(col: GridColumn): number {\r\n    if (col.haveSummary == true) {\r\n      return preciseSum((this.gridData ?? []).map((row: any) => row[col.field]));\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  rowSummary(row: any): number {\r\n    return preciseSum(this.columns.filter(col => col.rowSummary == true).map(col => row[col.field]));\r\n  }\r\n\r\n  onRowSelected(event: TableRowSelectEvent) {\r\n    this.selectedItem = event.data;\r\n    this._f6SourceRow = null;\r\n    this._cancelPendingDuplicateEmit();\r\n    if (this.selectKeyOnly == true) {\r\n      let selectionKey: any;\r\n      selectionKey = this.selectedItem[this.key];\r\n      this.onRowSelect.emit(selectionKey);\r\n    }\r\n    else {\r\n      this.onRowSelect.emit(this.selectedItems);\r\n    }\r\n  }\r\n\r\n  onRowUnselect(event: TableRowUnSelectEvent) {\r\n    this.selectedItem = undefined;\r\n    this._f6SourceRow = null;\r\n    this._cancelPendingDuplicateEmit();\r\n  }\r\n\r\n  selectionChange(event: any) {\r\n\r\n    let selection: any[] = [];\r\n\r\n    if (this.selectionMode == GridSelectionMode.Multiple) {\r\n      if (this.selectedItems) {\r\n        if (this.selectKeyOnly) {\r\n          let keys: Array<any> = [];\r\n          this.selectedItems.forEach((v: any) => { keys.push(v[this.key]) });\r\n          selection = keys;\r\n        }\r\n        else {\r\n          selection = this.selectedItems;\r\n        }\r\n      }\r\n      else {\r\n        selection = [];\r\n      }\r\n    }\r\n    else if (this.selectionMode == GridSelectionMode.Single) {\r\n      if (this.selectKeyOnly) {\r\n        selection = this.selectedItems ? [this.selectedItems[this.key]] : [];\r\n      }\r\n      else {\r\n        selection = this.selectedItems ? [this.selectedItems] : [];\r\n      }\r\n    }\r\n\r\n    if (this.selectionMode != GridSelectionMode.None) {\r\n      this.selectedItemsChange.emit(selection)\r\n    }\r\n  }\r\n\r\n  handleKeydown(event: KeyboardEvent) {\r\n    if (event.code === 'Space') {\r\n      event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  @HostListener('document:keydown', ['$event'])\r\n  handleGridKeydown(event: KeyboardEvent): void {\r\n    if (event.key === 'F6') {\r\n      event.preventDefault();\r\n\r\n      const source = this._f6SourceRow ?? this.selectedItem;\r\n      if (!source) return;\r\n\r\n      const isFirstDuplicate = !this._f6SourceRow;\r\n      this._f6SourceRow = source;\r\n\r\n      const result = this.duplicateRow(source, isFirstDuplicate, true);\r\n\r\n      if (result && !this._pendingDuplicateResult) {\r\n        this._pendingDuplicateResult = result;\r\n      }\r\n\r\n      if (this._pendingDuplicateEmitTimer) {\r\n        clearTimeout(this._pendingDuplicateEmitTimer);\r\n      }\r\n\r\n      this._pendingDuplicateEmitTimer = setTimeout(() => {\r\n        this._pendingDuplicateEmitTimer = null;\r\n        if (this._pendingDuplicateResult) {\r\n          this.addedRowEventEmitter.emit(this._pendingDuplicateResult);\r\n          this.rowDuplicatedEventEmitter.emit(this._pendingDuplicateResult);\r\n          this._pendingDuplicateResult = null;\r\n        }\r\n      }, 300);\r\n    }\r\n  }\r\n\r\n  onFocusOutRow(item: any) {\r\n    this.focusOutRow.emit(item);\r\n  }\r\n\r\n  customSort(event: SortEvent) {\r\n    if (event.data != null && event.data != undefined) {\r\n      event.data.sort((data1, data2) => {\r\n        if (event.field != null && event.field != undefined && event.order) {\r\n          let value1 = data1[event.field];\r\n          let value2 = data2[event.field];\r\n          let result = null;\r\n\r\n          if (value1 == null && value2 != null)\r\n            result = -1;\r\n          else if (value1 != null && value2 == null)\r\n            result = 1;\r\n          else if (value1 == null && value2 == null)\r\n            result = 0;\r\n          else if (typeof value1 === 'string' && typeof value2 === 'string')\r\n            result = value1.localeCompare(value2);\r\n          else\r\n            result = (value1 < value2) ? -1 : (value1 > value2) ? 1 : 0;\r\n\r\n          return (event.order * result);\r\n        }\r\n        return 0;\r\n      });\r\n    }\r\n  }\r\n\r\n  consult(key: string): void {\r\n    this.onConsultClicked.emit(key);\r\n  }\r\n\r\n  onCellLabelResolved(col: GridColumn, label: string, item: any): void {\r\n    item[this._getShadowSearchColumnLabel(col)] = label;\r\n  }\r\n\r\n  onCellValueChanged(col: GridColumn, newValue: any, item: any): void {\r\n    // Mark the grid itself dirty on any genuine cell edit. The grid instance lives\r\n    // for the whole form lifetime, so this flag survives row-data reassignment\r\n    // during recalculation (where transient cell inputs are recreated and lose\r\n    // their own isDirty), keeping the save-time change detection accurate.\r\n    this.isDirty = true;\r\n    if (col.type === InputTypes.SEARCH_COMBO && newValue == null) {\r\n      delete item[this._getShadowSearchColumnLabel(col)];\r\n    }\r\n    // send events\r\n    if (col.watchForChanges === true) {\r\n\r\n      let cellChangedResult: CellChangedResult = {\r\n        key: item[this.key],\r\n        field: col.field,\r\n        newValue: newValue\r\n      }\r\n      this.cellChanged.emit(cellChangedResult);\r\n    }\r\n\r\n    // recalculate currentRowNumber\r\n    if (col.field === this._autoRowNumberField) {\r\n      this._orderByRowNumber();\r\n    }\r\n\r\n    // check for duplicated rows\r\n    // if(this._equalityCheckOn && col.isEquatableCriteria){\r\n    //   console.log('found equatable : col:', col, 'row : ', item);\r\n    //   this._tryFindEquatable(item);\r\n    // }\r\n  }\r\n\r\n  public updateFormState(formState: FormState): void {\r\n    if (!this.genericValidationStateService) {\r\n      return;\r\n    }\r\n\r\n    this.genericValidationStateService.updateFormState(formState);\r\n  }\r\n\r\n  applyGlobalSearch(): void {\r\n    this.dt?.filterGlobal(this.searchValue, EditableGridComponent.DECIMAL_AWARE_CONTAINS_FILTER);\r\n  }\r\n\r\n  //#region private methods\r\n\r\n  private _initRow() {\r\n    let newRow: any = {};\r\n    if (this.columns) {\r\n      this.columns.forEach(col => {\r\n        if (col.type == InputTypes.DECIMAL_INPUT\r\n          || col.type == InputTypes.RATE_INPUT\r\n          || col.type == InputTypes.INTEGER\r\n          || col.type == InputTypes.CURRENCY_SOCIETE_INPUT\r\n          || col.type == InputTypes.CURRENCY_OTHER_INPUT) {\r\n          newRow[col.field] = 0;\r\n        }\r\n        else if (col.type == InputTypes.CHECKBOX) {\r\n          newRow[col.field] = false;\r\n        }\r\n        else {\r\n          newRow[col.field] = undefined;\r\n        }\r\n      });\r\n\r\n      if (this._isAutoRowNumber === true) {\r\n        newRow[this._autoRowNumberField] = this._nextRowNumber();\r\n      }\r\n      return newRow\r\n    }\r\n    return newRow;\r\n  }\r\n\r\n  private _initSaveEventSubscription() {\r\n    this.saveEventSubscription = this.saveEvent?.subscribe(\r\n      () => this.saveItems()\r\n    );\r\n  }\r\n\r\n  private _verifyGridRequirements() {\r\n    if (this.columns == null\r\n      || this.columns == undefined) {\r\n      throw new Error('grid columns can\\'t be null')\r\n    }\r\n    \r\n    let rowNumberColumns = this.columns.filter(c => c.isAutoRowNumberColumn === true);\r\n\r\n    if (rowNumberColumns.length > 1) {\r\n      throw new Error('grid columns can\\'t have more than one RowNumberColumn')\r\n    }\r\n    \r\n    if (rowNumberColumns.length == 1) {\r\n      this._isAutoRowNumber = true;\r\n      this._autoRowNumberField = rowNumberColumns[0].field;\r\n    }\r\n  }\r\n\r\n  private _initCurrentRowNumberAndOrderByRowNumber(): void {\r\n    if (this._isAutoRowNumber === true\r\n      && this._autoRowNumberField != undefined\r\n      && this._autoRowNumberField != null\r\n      && this.gridData.length > 0) {\r\n      this._orderByRowNumber();\r\n\r\n      this._currentRowNumber = this.gridData[this.gridData.length - 1][this._autoRowNumberField];\r\n    }\r\n  }\r\n\r\n  private _nextRowNumber(): number {\r\n    this._currentRowNumber = this.gridData.length + 1;\r\n    return this._currentRowNumber;\r\n  }\r\n\r\n  private _onDeleteRow(row: any): void {\r\n    if (row[this._autoRowNumberField] === this._currentRowNumber) {\r\n      this._currentRowNumber--;\r\n    }\r\n  }\r\n\r\n  private _orderByRowNumber(): void {\r\n    this.gridData.sort((a, b) => { return a[this._autoRowNumberField] - b[this._autoRowNumberField]; });\r\n  }\r\n\r\n  private _initEquatableFields(): void {\r\n    let equatableColumns = this.columns.filter(c => c.isEquatableCriteria == true);\r\n    if (equatableColumns) {\r\n      this._equalityCheckOn = true;\r\n      this._equatableFields = equatableColumns.map(c => c.field);\r\n    }\r\n  }\r\n\r\n  private _initSumAtFusionFields(): void {\r\n    let sumAtFusionColumns = this.columns.filter(c => c.isSumAtFusion == true);\r\n    if (sumAtFusionColumns) {\r\n      this._equalityCheckOn = true;\r\n      this._sumAtFusionFields = sumAtFusionColumns.map(c => c.field);\r\n    }\r\n  }\r\n\r\n  private _tryFindEquatable(row: any): void {\r\n    let foundEqualRow: boolean = false;\r\n    for (let i: number = 0; i < this.gridData.length; i++) {\r\n      console.log('proc row : ', this.gridData[i]);\r\n      let isCurrentRowEqual: boolean = true;\r\n      this._equatableFields?.forEach(f => {\r\n        console.log('proc field : ', f);\r\n        if (this.gridData[i][f] != row[f]) {\r\n          console.log('not equal ', row, this.gridData[i]);\r\n          isCurrentRowEqual = false;\r\n        }\r\n      });\r\n      if (isCurrentRowEqual) {\r\n        this._fusionRows(this.gridData[i], row);\r\n        foundEqualRow = true;\r\n        break;\r\n      }\r\n    }\r\n    if (foundEqualRow) {\r\n      console.log('deleting : ', row);\r\n      this.delete(row);\r\n    }\r\n  }\r\n\r\n  private _fusionRows(row1: any, row2: any) {\r\n    this._sumAtFusionFields?.forEach(f => {\r\n      row1[f] = preciseAdd(row1[f], row2[f]);\r\n    });\r\n  }\r\n\r\n  private _cancelPendingDuplicateEmit(): void {\r\n    this._pendingDuplicateResult = null;\r\n    if (this._pendingDuplicateEmitTimer) {\r\n      clearTimeout(this._pendingDuplicateEmitTimer);\r\n      this._pendingDuplicateEmitTimer = null;\r\n    }\r\n  }\r\n\r\n  private _syncGlobalFilterFields(): void {\r\n    const fields: string[] = [];\r\n    for (const col of this.selectedColumns) {\r\n      if (col.type === InputTypes.SEARCH_COMBO) {\r\n        fields.push(this._getShadowSearchColumnLabel(col));\r\n      } else {\r\n        fields.push(col.field);\r\n      }\r\n    }\r\n    this.globalFilterFields = fields;\r\n  }\r\n  \r\n  private _registerGridContainsFilter(): void {\r\n    // Custom PrimeNG filter used by applyGlobalSearch() instead of the built-in 'contains'.\r\n    // Extends the default behaviour with locale-aware decimal matching:\r\n    // a user in FR/AR locale types \"11,25\" but the stored JS number stringifies as \"11.25\",\r\n    // so a plain 'contains' check would miss it.\r\n    this._filterService.register(EditableGridComponent.DECIMAL_AWARE_CONTAINS_FILTER, (value: any, filter: string): boolean => {\r\n      if (filter == null || filter.trim() === '') return true;\r\n      if (value == null) return false;\r\n\r\n      const strValue = String(value).toLowerCase();\r\n      const strFilter = filter.trim().toLowerCase();\r\n\r\n      // Step 1 — direct match (handles all text columns and exact numeric matches)\r\n      if (strValue.includes(strFilter)) return true;\r\n\r\n      // Step 2 — decimal comma↔dot normalization.\r\n      // Two guards must both pass before normalizing:\r\n      //   • typeof value === 'number'  → only run on actual numeric values; text columns\r\n      //     containing dots (e.g. product codes like \"HP.XYZ\") are never touched.\r\n      //   • /^\\d+[,.]\\d+$/            → filter must look like a decimal number:\r\n      //       ^\\d+   one or more digits before the separator\r\n      //       [,.]   exactly one separator, comma or dot\r\n      //       \\d+$   one or more digits after the separator\r\n      //     This rejects free-text filters that happen to contain a comma (\"Caisse, France\")\r\n      //     and incomplete inputs (\"11,\" / \",25\").\r\n      if (typeof value === 'number' && /^\\d+[,.]\\d+$/.test(strFilter)) {\r\n        return strValue.includes(strFilter.replace(',', '.'));\r\n      }\r\n\r\n      return false;\r\n    });\r\n  }\r\n\r\n  private _cleanGridDataForEmit(): any[] {\r\n    return this.gridData.map(row => {\r\n      const clean: any = {};\r\n      for (const key of Object.keys(row)) {\r\n        if (!key.startsWith(EditableGridComponent.SEARCH_LABEL_PREFIX)) {\r\n          clean[key] = row[key];\r\n        }\r\n      }\r\n      return clean;\r\n    });\r\n  }\r\n\r\n  private _getShadowSearchColumnLabel(column: GridColumn): string {\r\n    return `${EditableGridComponent.SEARCH_LABEL_PREFIX}${column.field}`;\r\n  }\r\n  //#endregion\r\n}\r\n","<div class=\"card\">\r\n  <p-table #dt [selectionMode]=\"selectionMode\" [(selection)]=\"selectedItems\" editMode=\"row\"\r\n    [paginator]=\"gridData.length > pageSize\" [rowsPerPageOptions]=\"rowPerPage\" [rows]=\"pageSize\"\r\n    (onRowSelect)=\"onRowSelected($event)\" (onRowUnselect)=\"onRowUnselect($event)\" [scrollable]=\"true\"\r\n    (onColResize)=\"onColResize($event)\"\r\n    [resizableColumns]=\"true\" columnResizeMode=\"expand\" appendTo=\"body\" [value]=\"gridData\"\r\n    [columns]=\"selectedColumns\" [dataKey]=\"key\" [scrollHeight]=\"scrollHeight\" [styleClass]=\"'p-datatable-sm p-datatable-gridlines' + (stripedRows ? ' p-datatable-striped' : '')\"\r\n    (selectionChange)=\"selectionChange($event)\" #editableTable [totalRecords]=\"gridData.length\"\r\n    [globalFilterFields]=\"globalFilterFields\" [rowTrackBy]=\"rowTrackBy\" [tableStyle]=\"tableStyle\">\r\n\r\n    <ng-template pTemplate=\"caption\">\r\n      <div class=\"flex items-center gap-5 flex-row\">\r\n        <p-multiSelect [options]=\"columns\" [(ngModel)]=\"selectedColumns\"\r\n          selectedItemsLabel=\"{0} {{ 'columns_selected' | localize }}\" optionLabel=\"translatedHeader\"\r\n          [style]=\"{'min-width': '180px'}\" placeholder=\"{{ 'choose_columns' | localize }}\">\r\n          <ng-template let-option pTemplate=\"item\">\r\n            <div class=\"flex items-center gap-2\">\r\n              <span>{{ option.header | localize }}</span>\r\n            </div>\r\n          </ng-template>\r\n        </p-multiSelect>\r\n\r\n        <div *ngIf=\"showGlobalSearch\" class=\"flex items-center gap-1 w-8\">\r\n          <div presentationDesignerBase=\"global_search\" class=\"p-inputgroup rtl-mode h-2rem no-pad\">\r\n            <input class=\"\" type=\"text\" [(ngModel)]=\"searchValue\" pInputText class=\"border-round-lg\"\r\n              [placeholder]=\"'shared_edittable_search_placeholder' | localize\" (keydown.enter)=\"applyGlobalSearch()\">\r\n          </div>\r\n          <div presentationDesignerBase=\"search_button\">\r\n            <Tsi-Button styleClass=\"p-button-icon-only\" type=\"button\" icon=\"pi pi-search\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_search\"\r\n              (onClick)=\"applyGlobalSearch()\" />\r\n          </div>\r\n        </div>\r\n      </div> \r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"header\" let-columns>\r\n\r\n      <tr>\r\n        <ng-container *ngIf=\"selectionMode != multipleGridSelectionMode\">\r\n          <th pResizableColumn pFrozenColumn style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\"></th>\r\n        </ng-container>\r\n\r\n        <ng-container *ngIf=\"selectionMode == multipleGridSelectionMode\">\r\n          <th pResizableColumn pFrozenColumn style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\">\r\n            <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n          </th>\r\n        </ng-container>\r\n        \r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n\r\n        <!-- <th pResizableColumn pFrozenColumn *ngIf=\"showEditButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th> -->\r\n        \r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showDuplicateButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showConsultButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n        <th pResizableColumn pFrozenColumn *ngIf=\"showDeleteButton\" scope=\"col\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"></th>\r\n\r\n        <th pResizableColumn pFrozenColumn [frozen]=\"col.isFrozen\" [style]=\"col.style\" [ngStyle]=\"getColumnSizeStyle(col)\" scope=\"col\"\r\n          [attr.data-field]=\"col.field\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\"\r\n          style=\"min-width:3rem;\" pSortableColumn=\"{{col.field}}\" *ngFor=\"let col of columns\"\r\n          pTooltip=\"{{col.toolTipText | localize }}\" tooltipPosition=\"top\" pReorderableColumn>{{ col.header | localize\r\n          }}\r\n          <p-sortIcon field=\"{{col.field}}\"></p-sortIcon>\r\n          <Tsi-Bubble-Info [infoText]=\"col.infoText | localize\"></Tsi-Bubble-Info>\r\n        </th>\r\n        <th style=\"min-width:3rem\" *ngIf=\"showRowSummary\" scope=\"col\">{{'RowSummary' | localize}}</th>\r\n      </tr>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"body\" let-item let-editing=\"editing\" let-columns=\"columns\" let-rowIndex=\"rowIndex\">\r\n      \r\n      <tr [pEditableRow]=\"item\"\r\n        *ngIf=\"selectionMode == multipleGridSelectionMode || selectionMode == undefined; else selectionModeBlock\"\r\n        (focusOut)=\"onFocusOutRow(item)\">\r\n        \r\n        <td style=\"text-align: center;\">\r\n          <p-tableCheckbox [value]=\"item\" ></p-tableCheckbox>\r\n        </td>\r\n\r\n        <!-- <td pFrozenColumn style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\"> -->\r\n\r\n\r\n        <!-- <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td> -->\r\n\r\n        <!-- <td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n          <div class=\"flex align-items-center justify-content-center\">\r\n            <button *ngIf=\"!editing\" pButton pRipple type=\"button\" pInitEditableRow icon=\"pi pi-pencil\"\r\n              class=\"p-button-rounded p-button-text\">\r\n            </button>\r\n            <button *ngIf=\"editing\" pButton pRipple type=\"button\" pSaveEditableRow icon=\"pi pi-check\"\r\n              class=\"p-button-rounded p-button-text p-button-success -ml-1\">\r\n            </button>\r\n            <button *ngIf=\"editing\" pButton pRipple type=\"button\" pCancelEditableRow icon=\"pi pi-times\"\r\n              class=\"p-button-rounded p-button-text p-button-danger -ml-2\">\r\n            </button>\r\n          </div>\r\n        </td> -->\r\n        <td pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\"></td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showDuplicateButton\" style=\"left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-copy\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_dupliquer\"\r\n              styleClass=\"p-button-rounded p-button-text p-button-info\" (click)=\"duplicateRow(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showConsultButton\" style=\"left: -1rem !important; width:3rem !important;\"\r\n          class=\"p-1 btn-consult-style\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-eye\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_consulter\"\r\n              styleClass=\"p-button-rounded p-button-text p-button-secondary\" (click)=\"consult(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n        <td pFrozenColumn *ngIf=\"showDeleteButton\"\r\n          style=\"left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1 btn-delete-style\">\r\n          <div class=\"p-0\">\r\n            <Tsi-Button [disabled]=\"isDeleteButtonDisabled(item)\" type=\"button\" icon=\"p-button-icon pi pi-trash\"\r\n              [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_supprimer\"\r\n              styleClass=\"p-element p-button-rounded p-button-text p-button-danger p-button p-component p-button-icon-only\"\r\n              (click)=\"delete(item)\"></Tsi-Button>\r\n          </div>\r\n        </td>\r\n\r\n\r\n        <td class=\"ui-resizable-column\" pFrozenColumn [frozen]=\"col.isFrozen\" *ngFor=\"let col of columns\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\"\r\n          [ngStyle]=\"getBodyColumnStyle(col)\">\r\n          \r\n          \r\n          <div *ngIf=\"col.displayOnly || disabled; else ordinaryBloc\">\r\n\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteOutputBlock\">\r\n                  <Tsi-Search-Combo [disabled]=\"true\" [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [businessClass]=\"col.businessClass\" [currentRowItem]=\"item\" [(bind)]=\"item[col.field]\"\r\n                    id-field=\"{{col.idField}}\" [listSourceUrl]=\"col.listSourceUrl\" label-field=\"{{col.labelField}}\"\r\n                    [isFiltered]=\"col.isFiltered\" [datasource]=\"col.datasource\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Display -->\r\n                <ng-template #currencySocieteOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n                    <Tsi-Currency-Societe-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Societe-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Display -->\r\n                <ng-template #currencyOtherOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerOutputBlock\">\r\n                    <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Other-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Display -->\r\n                <ng-template #datePickerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxOutputBlock\">\r\n                    <Tsi-Date-Display [showTime]=\"col.showTime\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Date-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox-Display -->\r\n                <ng-template #checkBoxOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalOutputBlock\">\r\n                    <Tsi-Checkbox-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Checkbox-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Display -->\r\n                <ng-template #decimalOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                    <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"item[col.field]\"\r\n                      [numOfDecimal]=\"col.numOfDecimal\">\r\n                    </Tsi-Decimal-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer-Display -->\r\n                <ng-template #integerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                    <Tsi-Integer-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Integer-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Display -->\r\n                <ng-template #rateOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeOutputBlock\">\r\n                    <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Rate-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Display -->\r\n                <ng-template #timeOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaOutputBlock\">\r\n                    <tsi-time-display [inputData]=\"item[col.field]\"></tsi-time-display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Formula-Display -->\r\n                <ng-template #formulaOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextOutputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextOutputBlock>\r\n                  <ng-container>\r\n                    <span>\r\n                      {{item[col.field]}}\r\n                    </span>\r\n                  </ng-container>\r\n                </ng-template>\r\n          </div>\r\n\r\n          <ng-template #ordinaryBloc>\r\n\r\n            <!-- Tsi-Search-Combo -->\r\n            <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteInputBlock\">\r\n              <Tsi-Search-Combo [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                [businessClass]=\"col.businessClass\" [listSourceUrl]=\"col.listSourceUrl\" [(bind)]=\"item[col.field]\"\r\n                id-field=\"{{col.idField}}\" label-field=\"{{col.labelField}}\" [isFiltered]=\"col.isFiltered\"\r\n                [currentRowItem]=\"item\" (bindChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                [datasource]=\"col.datasource\" [showSearchButton]=\"col.showSearchButton ?? true\"\r\n                [showAddButton]=\"col.showAddButton ?? true\" [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n            </div>\r\n\r\n            <!-- Tsi-Currency-Societe-Input -->\r\n            <ng-template #currencySocieteInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherInputBlock\">\r\n                <Tsi-Currency-Societe-Input [inputName]=\"col.inputName\" [disabled]=\"col.disabled\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Currency-Societe-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Currency-Other-Input -->\r\n            <ng-template #currencyOtherInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerInputBlock\">\r\n                <Tsi-Currency-Other-Input [inputName]=\"col.inputName\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [currency]=\"col.currencyOtherCode\" [disabled]=\"col.disabled\">\r\n                </Tsi-Currency-Other-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Date-Picker -->\r\n            <ng-template #datePickerInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxInputBlock\">\r\n                <Tsi-Date-Picker [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [showTime]=\"col.showTime\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Date-Picker>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-CheckBox -->\r\n            <ng-template #checkBoxInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalInputBlock\">\r\n                <Tsi-CheckBox [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\" \r\n                  [isBinary]=\"col.isBinary ?? false\">\r\n                </Tsi-CheckBox>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Decimal-Input -->\r\n            <ng-template #decimalInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerInputBlock\">\r\n                <Tsi-Decimal-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [numOfDecimal]=\"col.numOfDecimal\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Decimal-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Integer -->\r\n            <ng-template #integerInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateInputBlock\">\r\n                <Tsi-Integer [inputName]=\"col.inputName\" [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                  [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                </Tsi-Integer>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Rate-Input -->\r\n            <ng-template #rateInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeInputBloc\">\r\n                <Tsi-Rate-Input [inputName]=\"col.inputName\" [numOfDecimal]=\"col.numOfDecimal\" [inputId]=\"col.field\"\r\n                  [(inputField)]=\"item[col.field]\" (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                  [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Rate-Input>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Time-picker bloc -->\r\n            <ng-template #timeInputBloc>\r\n              <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaInputBlock\">\r\n                <tsi-time-picker (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [inputName]=\"col.inputName\"\r\n                  [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\" [disabled]=\"col.disabled\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </tsi-time-picker>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <ng-template #formulaInputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextInputBlock\">\r\n                <!--<Tsi-Bubble-Info\r\n                  [infoText]=\"['formula_explication',\r\n                  ]\"></Tsi-Bubble-Info> -->\r\n                <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                  [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Text-Box -->\r\n            <ng-template #defaultTextInputBlock>\r\n              <ng-container>\r\n                <Tsi-Text-Box [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\" (keydown)=\"handleKeydown($event)\"\r\n                  (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                  [inputName]=\"col.inputName\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                </Tsi-Text-Box>\r\n              \r\n              </ng-container>\r\n            </ng-template>\r\n          </ng-template>\r\n\r\n        </td>\r\n\r\n        <td *ngIf=\"showRowSummary\" class=\"font-bold\">\r\n          {{rowSummary(item)}}\r\n        </td>\r\n      </tr>\r\n\r\n      <ng-template #selectionModeBlock>\r\n        <ng-container>\r\n          <tr [pEditableRow]=\"item\" [pSelectableRow]=\"item\" [pSelectableRowIndex]=\"rowIndex\"\r\n            (focusOut)=\"onFocusOutRow(item)\">\r\n\r\n       <!-- <td pFrozenColumn style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\"> -->\r\n\r\n            <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              </td>\r\n\r\n            <!-- <td *ngIf=\"selectionMode == multipleGridSelectionMode\" style=\"width: 2rem;\">\r\n              <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n            </td> -->\r\n\r\n            <!-- <td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem;left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              <div class=\"flex align-items-center justify-content-center\">\r\n                <button *ngIf=\"!editing\" pButton pRipple type=\"button\" pInitEditableRow icon=\"pi pi-pencil\"\r\n                  class=\"p-button-rounded p-button-text\">\r\n                </button>\r\n                <button *ngIf=\"editing\" pButton pRipple type=\"button\" pSaveEditableRow icon=\"pi pi-check\"\r\n                  class=\"p-button-rounded p-button-text p-button-success -ml-1\">\r\n                </button>\r\n                <button *ngIf=\"editing\" pButton pRipple type=\"button\" pCancelEditableRow icon=\"pi pi-times\"\r\n                  class=\"p-button-rounded p-button-text p-button-danger -ml-2\">\r\n                </button>\r\n              </div>\r\n            </td> -->\r\n            \r\n            <td pFrozenColumn *ngIf=\"showHaveSumary\" scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\">\r\n            </td>\r\n            \r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showDuplicateButton\"\r\n              style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-copy\"\r\n                  [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_dupliquer\"\r\n                  styleClass=\"p-button-rounded p-button-text p-button-info\" (click)=\"duplicateRow(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n\r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showConsultButton\"\r\n              style=\"left: 1rem !important; width:3rem !important;\" class=\"p-1 btn-consult-style\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button [buttonType]=\"buttonType.Button\" icon=\"p-button-icon pi pi-eye\"\r\n                  [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_consulter\"\r\n                  styleClass=\"p-button-rounded p-button-text p-button-secondary\" (click)=\"consult(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n\r\n            <td pFrozenColumn pResizableColumn *ngIf=\"showDeleteButton\" style=\"left: 1rem !important; width:3rem !important;\"\r\n              class=\"p-1 btn-delete-style\">\r\n              <div class=\"p-0\">\r\n                <Tsi-Button type=\"button\" icon=\"p-button-icon pi pi-trash\" [tooltipPosition]=\"tooltipPosition.Top\"\r\n                  tooltipText=\"shared_edittable_supprimer\"\r\n                  styleClass=\"p-element p-button-rounded p-button-text p-button-danger p-button p-component p-button-icon-only\"\r\n                  (click)=\"delete(item)\"></Tsi-Button>\r\n              </div>\r\n            </td>\r\n            \r\n            <td class=\"ui-resizable-column\" pFrozenColumn [frozen]=\"col.isFrozen\" *ngFor=\"let col of columns\"\r\n              [class.tsi-col-wrap]=\"shouldWrapColumn(col)\" [ngStyle]=\"getBodyColumnStyle(col)\">\r\n\r\n              <div *ngIf=\"col.displayOnly || disabled; else ordinaryBloc\">\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteOutputBlock\">\r\n                  <Tsi-Search-Combo [disabled]=\"true\" [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [businessClass]=\"col.businessClass\" [currentRowItem]=\"item\" [(bind)]=\"item[col.field]\"\r\n                    id-field=\"{{col.idField}}\" [listSourceUrl]=\"col.listSourceUrl\" label-field=\"{{col.labelField}}\"\r\n                    [isFiltered]=\"col.isFiltered\" [datasource]=\"col.datasource\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Display -->\r\n                <ng-template #currencySocieteOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n                    <Tsi-Currency-Societe-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Societe-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Display -->\r\n                <ng-template #currencyOtherOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerOutputBlock\">\r\n                    <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Currency-Other-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Display -->\r\n                <ng-template #datePickerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxOutputBlock\">\r\n                    <Tsi-Date-Display [showTime]=\"col.showTime\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Date-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox-Display -->\r\n                <ng-template #checkBoxOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalOutputBlock\">\r\n                    <Tsi-Checkbox-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Checkbox-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Display -->\r\n                <ng-template #decimalOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                    <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"item[col.field]\"\r\n                      [numOfDecimal]=\"col.numOfDecimal\">\r\n                    </Tsi-Decimal-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer-Display -->\r\n                <ng-template #integerOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                    <Tsi-Integer-Display [inputData]=\"item[col.field]\">\r\n                    </Tsi-Integer-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Display -->\r\n                <ng-template #rateOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeOutputBlock\">\r\n                    <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"item[col.field]\">\r\n                    </Tsi-Rate-Display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Display -->\r\n                <ng-template #timeOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME; else formulaOutputBlock\">\r\n                    <tsi-time-display [inputData]=\"item[col.field]\"></tsi-time-display>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Formula-Display -->\r\n                <ng-template #formulaOutputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextOutputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextOutputBlock>\r\n                  <ng-container>\r\n                    <span>\r\n                      {{item[col.field]}}\r\n                    </span>\r\n                  </ng-container>\r\n                </ng-template>\r\n              </div>\r\n              \r\n              <ng-template #ordinaryBloc>\r\n                <!-- Tsi-Search-Combo -->\r\n                <div *ngIf=\"col.type == inputTypes.SEARCH_COMBO; else currencySocieteInputBlock\">\r\n                  <Tsi-Search-Combo [elementSourceUrl]=\"col.elementSourceUrl\"\r\n                    [listSourceUrl]=\"col.listSourceUrl\" [(bind)]=\"item[col.field]\" id-field=\"{{col.idField}}\"\r\n                    label-field=\"{{col.labelField}}\" [isFiltered]=\"col.isFiltered\" [businessClass]=\"col.businessClass\"\r\n                    (bindChange)=\"onCellValueChanged(col, $event, item)\" [currentRowItem]=\"item\"\r\n                    [datasource]=\"col.datasource\" [disabled]=\"col.disabled\"\r\n                    [showSearchButton]=\"col.showSearchButton ?? true\" [showAddButton]=\"col.showAddButton ?? true\"\r\n                    [showUpdateButton]=\"col.showUpdateButton ?? undefined\"\r\n                    [showConsultButton]=\"col.showConsultButton ?? undefined\"\r\n                    [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                    (selectedLabelChange)=\"onCellLabelResolved(col, $event, item)\"\r\n                    [inputName]=\"col.inputName\"></Tsi-Search-Combo>\r\n                </div>\r\n\r\n                <!-- Tsi-Currency-Societe-Input -->\r\n                <ng-template #currencySocieteInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherInputBlock\">\r\n                    <Tsi-Currency-Societe-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Currency-Societe-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Currency-Other-Input -->\r\n                <ng-template #currencyOtherInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else datePickerInputBlock\">\r\n                    <Tsi-Currency-Other-Input [disabled]=\"col.disabled\" [inputName]=\"col.inputName\"\r\n                      [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\" [currency]=\"col.currencyOtherCode\">\r\n                    </Tsi-Currency-Other-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Date-Picker -->\r\n                <ng-template #datePickerInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DATE; else checkBoxInputBlock\">\r\n                    <Tsi-Date-Picker [showTime]=\"col.showTime\" [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Date-Picker>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-CheckBox -->\r\n                <ng-template #checkBoxInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.CHECKBOX; else decimalInputBlock\">\r\n                    <Tsi-CheckBox [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      [isBinary]=\"col.isBinary ?? false\">\r\n                    </Tsi-CheckBox>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Decimal-Input -->\r\n                <ng-template #decimalInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerInputBlock\">\r\n                    <Tsi-Decimal-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      [(inputField)]=\"item[col.field]\" [numOfDecimal]=\"col.numOfDecimal\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                    </Tsi-Decimal-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Integer -->\r\n                <ng-template #integerInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateInputBlock\">\r\n                    <Tsi-Integer [class]=\"'max-w-4rem'\" [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\">\r\n                    </Tsi-Integer>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Rate-Input -->\r\n                <ng-template #rateInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else timeInputBloc\">\r\n                    <Tsi-Rate-Input [inputName]=\"col.inputName\" [inputId]=\"col.field\"\r\n                      [(inputField)]=\"item[col.field]\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [disabled]=\"col.disabled\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Rate-Input>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Time-Picker -->\r\n                <ng-template #timeInputBloc>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.TIME else formulaInputBlock\">\r\n                    <tsi-time-picker (inputFieldChange)=\"onCellValueChanged(col, $event, item)\"\r\n                      [inputName]=\"col.inputName\" [inputId]=\"col.field\" [(inputField)]=\"item[col.field]\"\r\n                      [disabled]=\"col.disabled\" [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </tsi-time-picker>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <ng-template #formulaInputBlock>\r\n                  <ng-container *ngIf=\"col.type == inputTypes.FORMULA_TEXT_BOX; else defaultTextInputBlock\">\r\n                    <Tsi-Formula-Box [inputName]=\"col.inputName\" [(value)]=\"item[col.field]\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\"></Tsi-Formula-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n\r\n                <!-- Tsi-Text-Box -->\r\n                <ng-template #defaultTextInputBlock>\r\n                  <ng-container>\r\n                    <Tsi-Text-Box [inputId]=\"col.field\" [disabled]=\"col.disabled\"\r\n                      [(inputField)]=\"item[col.field]\" (keydown)=\"handleKeydown($event)\"\r\n                      (inputFieldChange)=\"onCellValueChanged(col, $event, item)\" [inputName]=\"col.inputName\"\r\n                      [validationStatusCssClass]=\"col.validationStatusCssClass\">\r\n                    </Tsi-Text-Box>\r\n                  </ng-container>\r\n                </ng-template>\r\n              </ng-template>\r\n\r\n            </td>\r\n            <td *ngIf=\"showRowSummary\" class=\"font-bold\">\r\n              {{rowSummary(item)}}\r\n            </td>\r\n          </tr>\r\n        </ng-container>\r\n      </ng-template>\r\n\r\n    </ng-template>\r\n\r\n    <ng-template *ngIf=\"showHaveSumary\" pTemplate=\"footer\" let-columns>\r\n\r\n      <tr class=\"tfooter\">\r\n        <!-- <td pFrozenColumn scope=\"col\" style=\"left: 1rem !important; width:3rem !important;\"></td> -->\r\n        <td *ngIf=\"selectionMode == multipleGridSelectionMode\"\r\n          style=\"min-width:2rem; left: 1rem !important; width:2rem !important;\">\r\n          <p-tableHeaderCheckbox #tableHeaderCheckbox></p-tableHeaderCheckbox>\r\n        </td>\r\n        <td pFrozenColumn scope=\"col\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\">Total</td>\r\n        <td pFrozenColumn *ngIf=\"showDeleteButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\">\r\n        <td pFrozenColumn style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n          <!--<td pFrozenColumn *ngIf=\"showEditButton\" style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\"\r\n          class=\"p-1\"> -->\r\n        <td pFrozenColumn *ngIf=\"showDuplicateButton\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td>\r\n        <td pFrozenColumn *ngIf=\"showConsultButton\"\r\n          style=\"min-width:3rem; left: 1rem !important; width:3rem !important;\" class=\"p-1\">\r\n        </td>\r\n        <td pFrozenColumn [frozen]=\"col.isFrozen\" [style]=\"col.style\" [ngStyle]=\"getColumnSizeStyle(col)\" scope=\"col\" *ngFor=\"let col of columns\"\r\n          [class.tsi-col-wrap]=\"shouldWrapColumn(col)\">\r\n          <div *ngIf=\"col.haveSummary\">\r\n            <!-- Tsi-Currency-Societe-Display -->\r\n            <div *ngIf=\"col.type == inputTypes.CURRENCY_SOCIETE_INPUT; else currencyOtherOutputBlock\">\r\n              <Tsi-Currency-Societe-Display [inputData]=\"getSummary(col)\">\r\n              </Tsi-Currency-Societe-Display>\r\n            </div>\r\n\r\n            <!-- Tsi-Currency-Other-Display -->\r\n            <ng-template #currencyOtherOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.CURRENCY_OTHER_INPUT; else decimalOutputBlock\">\r\n                <Tsi-Currency-Other-Display [currency]=\"col.currencyOtherCode\" [inputData]=\"getSummary(col)\">\r\n                </Tsi-Currency-Other-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Decimal-Display -->\r\n            <ng-template #decimalOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.DECIMAL_INPUT; else integerOutputBlock\">\r\n                <Tsi-Decimal-Display [formatDecimal]=\"col.formatDecimal\" [inputData]=\"getSummary(col)\"\r\n                  [numOfDecimal]=\"col.numOfDecimal\">\r\n                </Tsi-Decimal-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Integer-Display -->\r\n            <ng-template #integerOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.INTEGER; else rateOutputBlock\">\r\n                <Tsi-Integer-Display [inputData]=\"getSummary(col)\">\r\n                </Tsi-Integer-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Tsi-Rate-Display -->\r\n            <ng-template #rateOutputBlock>\r\n              <ng-container *ngIf=\"col.type == inputTypes.RATE_INPUT; else defaultTextOutputBlock\">\r\n                <Tsi-Rate-Display [isFraction]=\"col.isFraction\" [inputData]=\"getSummary(col)\">\r\n                </Tsi-Rate-Display>\r\n              </ng-container>\r\n            </ng-template>\r\n\r\n            <!-- Default -->\r\n            <ng-template #defaultTextOutputBlock>\r\n              <ng-container>\r\n                <span>\r\n                  {{getSummary(col)}}\r\n                </span>\r\n              </ng-container>\r\n            </ng-template>\r\n          </div>\r\n        </td>\r\n      </tr>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"summary\">\r\n      <tr>\r\n        {{'TotalRecordsCount' | localize }} {{gridData.length}}\r\n      </tr>\r\n    </ng-template>\r\n  </p-table>\r\n  <div>\r\n    <Tsi-Button *ngIf=\"showAddButton\" style=\"height: 20px;width: 20px;\" icon=\"p-button-icon pi pi-plus\" type=\"button\"\r\n      [tooltipPosition]=\"tooltipPosition.Top\" tooltipText=\"shared_edittable_ajouter\"\r\n      styleClass=\"p-element p-button-sm p-button-success p-button-text p-button p-component p-button-icon-only ng-star-inserted\"\r\n      (click)=\"addRow()\"></Tsi-Button>\r\n  </div>\r\n</div>"]}