@sankhyalabs/ezui 0.0.0-bugfix-dev-KB-08202.0

package/dist/collection/components/ez-grid/controller/ag-grid/AgGridController.js

@@ -0,0 +1,791 @@
+import { ApplicationContext, DataType, MaskFormatter, NumberUtils, SortMode, StringUtils, UserInterface } from '@sankhyalabs/core';
+import { Grid, } from 'ag-grid-community';
+import { Grid as EnterpriseGrid, LicenseManager } from 'ag-grid-enterprise';
+import DataSource from './DataSource';
+import { EzGridCustomHeader } from './components/EzGridCustomHeader';
+import { CellRendererStatus } from './components/cellRendererStatus';
+import SelectionHeader from './components/selectionHeader';
+import gridTerms from './i18n/pt-BR.js';
+import { DISTINCT_FILTER_NAME_PREFIX } from '../../../../utils/constants';
+import { calcFilterColumnLeftPosition } from './AgGridUtils';
+import GridEditionManager from './GridEditionManager';
+export default class AgGridController {
+  configFilterColumn(filterColumn) {
+    this._filterColumn = filterColumn;
+    this._filterColumn.addEventListener('applyFilterColumnOptions', this.handleFilteredColumnsChanged.bind(this));
+  }
+  handleFilteredColumnsChanged(event) {
+    const applied = event.detail;
+    this._filteredColumns.set(applied.field, applied.values);
+    this._gridOptions.api.refreshHeader();
+    this._dataUnit.loadData();
+  }
+  showFilterColumn(configs) {
+    var _a;
+    (_a = this._filterColumn) === null || _a === void 0 ? void 0 : _a.show(configs);
+  }
+  constructor(enterprise) {
+    this.DEFAULT_ROW_HEIGHT = 30;
+    this.DEFAULT_HEADER_ROW_HEIGHT = 32;
+    this.CHECK_BOX_COL_ID = 'checkBoxColumn';
+    this.STATUS_COL_ID = 'statusColumn';
+    this.RECORD_ARCHIVE_COL_ID = '__RECORD_ARCHIVE__';
+    this.BLOCK_LOAD_DEBOUNCE = 400;
+    this.DEFAULT_FONT_SIZE = 14;
+    this.DEFAULT_ICON_SIZE = 12;
+    this.DEFAULT_MAX_SIZE = 200;
+    this._menuItems = [];
+    this._idAttribName = '__record__id__';
+    this._gridConfig = [];
+    this._filteredColumns = new Map();
+    this._filterColumnleftPosition = '0px';
+    this._enterprise = enterprise;
+  }
+  getGridConfig() {
+    return this._gridConfig;
+  }
+  getGridApi() {
+    return this._gridOptions.api;
+  }
+  getSort() {
+    const sortedColumns = [];
+    this._gridOptions.columnApi
+      .getColumnState()
+      .sort((colA, colB) => colA.sortIndex - colB.sortIndex)
+      .forEach(({ colId, sort }) => {
+      if (sort) {
+        const field = this._dataUnit.getField(colId);
+        const mode = sort === 'asc' ? SortMode.ASC : SortMode.DESC;
+        const sortField = field ? { field: field.name, dataType: field.dataType, mode } : { field: colId, dataType: DataType.TEXT, mode };
+        sortedColumns.push(sortField);
+      }
+    });
+    return sortedColumns;
+  }
+  getFilter() {
+    if (!this._filteredColumns || this._filteredColumns.size === 0) {
+      return;
+    }
+    return Array.from(this._filteredColumns.entries())
+      .map(([column, items]) => {
+      var _a;
+      const checkedOptions = items.filter(option => option.check);
+      if (checkedOptions.length > 0) {
+        const fieldDescriptor = this._dataUnit.getField(column);
+        const dataType = (_a = fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.dataType) !== null && _a !== void 0 ? _a : DataType.TEXT;
+        let placeholders = '';
+        const params = [];
+        checkedOptions.forEach(option => {
+          if (placeholders.length > 0) {
+            placeholders = placeholders + ',';
+          }
+          const paramName = `PARAM_${column}_${params.length + 1}`;
+          placeholders = `${placeholders}:${paramName}`; //FIXME: trocar por ? quando o backend estiver funcionando
+          params.push({
+            dataType: dataType === DataType.OBJECT ? DataType.TEXT : dataType,
+            name: paramName,
+            value: option.value,
+          });
+        });
+        const columnExpression = dataType === DataType.DATE ? `onlydate(this.${column})` : `this.${column}`;
+        return {
+          name: `${DISTINCT_FILTER_NAME_PREFIX}${column}`,
+          expression: `${columnExpression} in (${placeholders})`,
+          params,
+        };
+      }
+      return undefined;
+    })
+      .filter(item => item != undefined);
+  }
+  initDatagrid(container, options) {
+    var _a;
+    if (this._grid === undefined) {
+      LicenseManager.setLicenseKey(ApplicationContext.getContextValue('__EZUI__GRID_LICENSE__'));
+      this._columnStateChangeCallback = options.onColumnStateChange;
+      this._selectionChangeCallback = options.onSelectionChange;
+      this._doubleClickCallBack = options.onDoubleClick;
+      this._multipleSelection = options.allowMultipleSelection;
+      this._dataUnit = options.dataUnit;
+      this._editionManager = new GridEditionManager(this._dataUnit, options.useEnterLikeTab, options.recordsValidator, options.editionIsDisabled);
+      this._statusResolver = options.statusResolver;
+      if (this._dataUnit) {
+        this._dataUnit.sortingProvider = this;
+        this._dataUnit.addFilterProvider(this);
+      }
+      this._gridOptions = {
+        localeText: gridTerms,
+        enableRangeSelection: this._multipleSelection,
+        rowSelection: this._multipleSelection ? 'multiple' : 'single',
+        sortingOrder: ['desc', 'asc', null],
+        blockLoadDebounceMillis: this.BLOCK_LOAD_DEBOUNCE,
+        navigateToNextCell: this.navigateToNextCell.bind(this),
+        getRowNodeId: this._dataUnit ? params => (typeof params === 'string' ? params : params[this._idAttribName]) : undefined,
+        getMainMenuItems: (params) => this.buildMenuItemOptions(params),
+        postProcessPopup: (params) => this.setFilterColumnLeftPosition(params),
+        getRowHeight: this.getRowHeight.bind(this),
+        defaultColDef: {
+          headerClass: 'ez-grid__cell-header',
+          cellClass: 'ez-grid__cell-body',
+          cellStyle: {
+            height: '100%'
+          }
+        },
+        components: Object.assign({ ezGridHeaderComponent: SelectionHeader, ezGridCustomHeader: EzGridCustomHeader }, this._editionManager.getComponents()),
+        context: {
+          editionManager: this._editionManager,
+          dataUnit: this._dataUnit,
+          headerCheckStatusGetter: () => this.getSelectionHeaderStatus(),
+          headerCheckStatusSetter: (selectAll) => this.updateSelectionForAll(selectAll),
+        },
+      };
+      this.defineRowModelType(this._gridOptions, options);
+      this.setOptionsEvents(this._gridOptions);
+      this.setOptionsSupress(this._gridOptions);
+      this._gridOptions = this._editionManager.configureGrid(this._gridOptions);
+      if (this._enterprise) {
+        this._grid = new EnterpriseGrid(container, this._gridOptions);
+      }
+      else {
+        this._grid = new Grid(container, this._gridOptions);
+      }
+      const selection = (_a = this._dataUnit) === null || _a === void 0 ? void 0 : _a.getSelectionInfo();
+      if (selection === null || selection === void 0 ? void 0 : selection.isAllRecords()) {
+        this.selectAll(true);
+      }
+      else {
+        this.selectRows((selection === null || selection === void 0 ? void 0 : selection.recordIds) || [], true);
+      }
+      this._gridOptions.api.setHeaderHeight(this.getHeaderRowHeight());
+    }
+  }
+  setFilterColumnLeftPosition(params) {
+    if (params.type === 'columnMenu') {
+      const ePopup = params.ePopup;
+      const leftString = ePopup.style.left.replace('px', '');
+      this._filterColumnleftPosition = `${calcFilterColumnLeftPosition(parseInt(leftString))}px`;
+      return;
+    }
+  }
+  buildMenuItemOptions(params) {
+    const col = params.column;
+    const items = [];
+    if (col.getColDef().sortable) {
+      items.push(this.buildMenuItemOptionSort(params, 'asc'));
+      items.push(this.buildMenuItemOptionSort(params, 'desc'));
+      items.push(this.buildMenuItemFilterColumn(params));
+    }
+    this._menuItems.forEach(m => items.push({
+      icon: m.icon,
+      name: m.label,
+      action: () => m.action(params),
+    }));
+    items.push(this.buildMenuItemOptionPin(params));
+    return items;
+  }
+  buildMenuItemOptionSort(params, sortOrder) {
+    return {
+      icon: `<i class='ez-icon-arrow_downward'></i>`,
+      name: sortOrder === 'asc' ? 'Ordenar Ascendente' : 'Ordenar Descendente',
+      action: () => this.sortDataByColumn(params, sortOrder),
+    };
+  }
+  buildMenuItemFilterColumn(params) {
+    const columnName = params.column.getId();
+    const columnLabel = params.column.getColDef().headerName;
+    return {
+      icon: `<i class='ez-icon-filter'></i>`,
+      name: 'Filtrar',
+      action: () => this.showFilterColumn({ columnName, columnLabel, leftPosition: this._filterColumnleftPosition, filteredOptions: this._filteredColumns.get(columnName) }),
+    };
+  }
+  buildMenuItemOptionPin(params) {
+    const { column, columnApi } = params;
+    const isPinned = params.column.isPinned();
+    return {
+      icon: `<i class='ez-icon-${isPinned ? 'un-pin' : 'push-pin'}'></i>`,
+      name: isPinned ? 'Desafixar coluna' : 'Fixar coluna',
+      action: () => {
+        columnApi.applyColumnState({
+          state: [{ colId: column.getColId(), pinned: column.isPinned() ? null : 'left' }],
+        });
+      },
+    };
+  }
+  sortDataByColumn(params, order) {
+    const col = params.column;
+    const colApi = params.columnApi;
+    if (col.getSort() === order) {
+      colApi.applyColumnState({
+        defaultState: { sort: null },
+      });
+    }
+    else {
+      colApi.applyColumnState({
+        state: [{ colId: col.getColId(), sort: order }],
+        defaultState: { sort: null },
+      });
+    }
+  }
+  getRowHeight() {
+    return this.DEFAULT_ROW_HEIGHT;
+  }
+  getHeaderRowHeight() {
+    return this.DEFAULT_HEADER_ROW_HEIGHT;
+  }
+  navigateToNextCell(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    switch (params.key) {
+      case 'ArrowUp':
+        if (((_a = this._dataUnit) === null || _a === void 0 ? void 0 : _a.hasPrevious()) === false) {
+          return null;
+        }
+        this._gridOptions.api.deselectAll();
+        if (((_b = params.nextCellPosition) === null || _b === void 0 ? void 0 : _b.rowIndex) < 0) {
+          (_c = this._dataUnit) === null || _c === void 0 ? void 0 : _c.previousRecord();
+          return null;
+        }
+        else {
+          (_d = this._dataUnit) === null || _d === void 0 ? void 0 : _d.setSelectionByIndex([params.nextCellPosition.rowIndex]);
+          return params.nextCellPosition;
+        }
+      case 'ArrowDown':
+        if (((_e = this._dataUnit) === null || _e === void 0 ? void 0 : _e.hasNext()) === false) {
+          return null;
+        }
+        this._gridOptions.api.deselectAll();
+        if ((_f = params.nextCellPosition) === null || _f === void 0 ? void 0 : _f.rowIndex) {
+          (_g = this._dataUnit) === null || _g === void 0 ? void 0 : _g.setSelectionByIndex([params.nextCellPosition.rowIndex]);
+        }
+        else {
+          (_h = this._dataUnit) === null || _h === void 0 ? void 0 : _h.nextRecord();
+        }
+        return params.nextCellPosition;
+      case 'ArrowLeft':
+      case 'ArrowRight':
+        if (((_j = params.nextCellPosition) === null || _j === void 0 ? void 0 : _j.column.colDef.headerName) !== '') {
+          return params.nextCellPosition;
+        }
+        else {
+          return null;
+        }
+    }
+    return null;
+  }
+  defineRowModelType(opt, sourceOptions) {
+    if (this._dataUnit != undefined) {
+      opt.rowModelType = 'serverSide';
+      opt.serverSideDatasource = new DataSource(this._dataUnit, this, sourceOptions);
+      opt.serverSideSortOnServer = true;
+      opt.columnDefs = this._colDefs;
+    }
+  }
+  setOptionsEvents(opt) {
+    opt.onSortChanged = e => this.onCallStateChange('sort', e);
+    opt.onColumnResized = e => this.onCallStateChange('columnResize', e);
+    opt.onColumnPinned = e => this.onCallStateChange('columnPinned', e);
+    opt.onColumnMoved = e => this.onCallStateChange('columnMoved', e);
+    opt.onColumnVisible = e => this.onCallStateChange('visibleChange', e);
+    opt.onSelectionChanged = e => this.onSelectionChange(e);
+    opt.onRowDoubleClicked = evt => this.onRowDoubleClick(evt);
+    opt.onDragStopped = evt => this.onCallStateChange('columnMovedEnd', evt);
+    opt.onCellClicked = evt => this.onCellClicked(evt);
+  }
+  setOptionsSupress(opt) {
+    opt.suppressDragLeaveHidesColumns = true;
+    opt.suppressMenuHide = true;
+  }
+  getSelectionHeaderStatus() {
+    const records = this._dataUnit.records;
+    if (records && records.length === 0) {
+      return false;
+    }
+    const selectionInfo = this._dataUnit.getSelectionInfo();
+    if (selectionInfo.isAllRecords()) {
+      return true;
+    }
+    const selection = selectionInfo.recordIds;
+    if (selection == undefined || selection.length === 0) {
+      return false;
+    }
+    let status = undefined;
+    for (let i = 0; i < records.length; i++) {
+      const current = selection.includes(records[i].__record__id__);
+      if (status != undefined && current !== status) {
+        return undefined;
+      }
+      status = current;
+    }
+    return status;
+  }
+  updateSelectionForAll(selectAll) {
+    this._dataUnit.updatePageSelection(selectAll ? this._dataUnit.records.map(r => r.__record__id__) : []);
+  }
+  setData(data) {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    this._gridOptions.api.setRowData(data);
+  }
+  addRows() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+  }
+  updateRows() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+  }
+  selectAll(quietly = false) {
+    try {
+      this._gridOptions.context.selectionChangeQuietly = quietly;
+      this._gridOptions.api.forEachNode(node => {
+        if (!node.isSelected()) {
+          node.setSelected(true);
+        }
+      });
+    }
+    finally {
+      const newContext = Object.assign({}, this._gridOptions.context);
+      delete newContext.selectionChangeQuietly;
+      this._gridOptions.context = newContext;
+    }
+  }
+  selectRows(rowIds, quietly = false) {
+    var _a;
+    try {
+      this._gridOptions.context.selectionChangeQuietly = quietly;
+      if (this._grid === undefined) {
+        throw new Error('Erro interno: Grid ainda não inicializado.');
+      }
+      let lastSelected;
+      this._gridOptions.api.forEachNode(node => {
+        if (rowIds && rowIds.includes(node.id)) {
+          if (!node.isSelected()) {
+            node.setSelected(true);
+            lastSelected = node;
+          }
+        }
+        else {
+          if (node.isSelected()) {
+            node.setSelected(false);
+          }
+        }
+      });
+      const selectionHeader = this._gridOptions.context.selectionHeader;
+      if (selectionHeader) {
+        selectionHeader.updateCheckbox();
+      }
+      if (lastSelected) {
+        (_a = this._gridOptions.api) === null || _a === void 0 ? void 0 : _a.ensureNodeVisible(lastSelected);
+      }
+    }
+    finally {
+      const newContext = Object.assign({}, this._gridOptions.context);
+      delete newContext.selectionChangeQuietly;
+      this._gridOptions.context = newContext;
+    }
+  }
+  removeRows() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    this._gridOptions.api.refreshServerSide({ purge: true });
+  }
+  changeValues(changes, rowIds) {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    if (changes) {
+      let rowNodes;
+      if (rowIds) {
+        rowNodes = [];
+        rowIds.forEach(id => {
+          const rowNode = this._gridOptions.api.getRowNode(id);
+          if (rowNode) {
+            rowNodes.push(rowNode);
+          }
+        });
+      }
+      else {
+        rowNodes = this._gridOptions.api.getSelectedNodes();
+      }
+      rowNodes.forEach(r => {
+        const data = r.data;
+        Object.entries(changes).forEach(([field, value]) => {
+          data[field] = value;
+        });
+        r.setData(data);
+      });
+    }
+  }
+  refresh() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    this._gridOptions.api.refreshServerSide({ purge: false });
+  }
+  setFocusFirstRow() {
+    const firstRow = this._gridOptions.api.getDisplayedRowAtIndex(0);
+    if (firstRow) {
+      this.setFocusOnRow(firstRow.rowIndex);
+    }
+  }
+  setFocusLastRow() {
+    const lastRow = this._gridOptions.api.getDisplayedRowAtIndex(this._gridOptions.api.getLastDisplayedRow());
+    if (lastRow) {
+      this.setFocusOnRow(lastRow.rowIndex);
+    }
+  }
+  setFocusOnRow(rowIndex) {
+    let displayedColumns = this._gridOptions.columnApi.getAllDisplayedColumns();
+    let firstCell = displayedColumns.find(column => column.getColDef().headerName !== '');
+    this._gridOptions.api.ensureColumnVisible(firstCell);
+    this._gridOptions.api.ensureIndexVisible(rowIndex);
+    this._gridOptions.api.setFocusedCell(rowIndex, firstCell);
+  }
+  setColumnsDef(cols) {
+    const newColDefs = [
+      Object.assign({ colId: this.CHECK_BOX_COL_ID, headerName: '', checkboxSelection: true, width: 29, suppressMovable: true, suppressAutoSize: true, suppressMenu: true, lockPosition: true, pinned: true }, (this._multipleSelection && { headerComponent: 'ezGridHeaderComponent', headerClass: 'ag-column-select-header' })),
+    ];
+    if (this._statusResolver != undefined) {
+      newColDefs.push({
+        colId: this.STATUS_COL_ID,
+        headerName: '',
+        checkboxSelection: false,
+        headerCheckboxSelection: false,
+        width: 29,
+        suppressMovable: true,
+        suppressAutoSize: true,
+        suppressMenu: true,
+        lockPosition: true,
+        pinned: true,
+        cellRenderer: CellRendererStatus,
+        cellRendererParams: {
+          statusResolver: this._statusResolver,
+        },
+        cellStyle: {
+          'text-align': 'center',
+        },
+      });
+    }
+    cols.forEach(c => {
+      newColDefs.push(this.buildColDef(c));
+    });
+    this._colDefs = newColDefs;
+    if (this._gridOptions && this._gridOptions.api) {
+      this._gridOptions.api.setColumnDefs(this._colDefs);
+    }
+  }
+  getColumnsDef() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    const colDef = this._gridOptions.columnApi.getColumns();
+    return colDef
+      .filter(c => ![this.CHECK_BOX_COL_ID, this.STATUS_COL_ID].includes(c.getColId()))
+      .map(c => {
+      const def = c.getColDef();
+      const colDef = { name: def.field, label: def.headerName };
+      this.conditionalSet(colDef, 'sortable', def.sortable);
+      this.conditionalSet(colDef, 'resizable', def.resizable);
+      this.conditionalSet(colDef, 'sort', def.sort);
+      this.conditionalSet(colDef, 'sortIndex', def.sortIndex);
+      this.conditionalSet(colDef, 'width', def.width);
+      this.conditionalSet(colDef, 'pinned', def.pinned !== null);
+      this.conditionalSet(colDef, 'hidden', def.hide);
+      return colDef;
+    });
+  }
+  setColumnsState(state) {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    const colDef = this._gridOptions.columnApi.getColumns();
+    let columns = this.getColumnsDef();
+    let visibleColumns = [];
+    //Existem colunas implícitas que não tem estado, essas colunas são sempre as primeiras.
+    //Como vamos reordenar, precisamos considerar o deslocamento provocado por elas.
+    const columnsOffset = colDef.length - columns.length;
+    let sort = [];
+    state.forEach((cfgColumn, index) => {
+      const colWidth = this.getColumnWidth(cfgColumn);
+      this._gridOptions.columnApi.moveColumn(cfgColumn.name, index + columnsOffset);
+      this._gridOptions.columnApi.setColumnWidth(cfgColumn.name, colWidth);
+      visibleColumns.push(cfgColumn.name);
+      if (cfgColumn.ascending !== undefined) {
+        sort.push({ colId: cfgColumn.name, sort: cfgColumn.ascending !== true ? 'desc' : 'asc', sortIndex: cfgColumn.orderIndex });
+      }
+    });
+    let invisibleColumns = columns.filter(column => !visibleColumns.includes(column.name)).map(column => column.name);
+    this._gridOptions.columnApi.setColumnsVisible(visibleColumns, true);
+    this._gridOptions.columnApi.setColumnsVisible(invisibleColumns, false);
+    this._gridOptions.columnApi.applyColumnState({
+      state: sort,
+      defaultState: { sort: null },
+    });
+    this._gridConfig = state;
+  }
+  getColumnsState() {
+    if (this._grid === undefined) {
+      throw new Error('Erro interno: Grid ainda não inicializado.');
+    }
+    const colState = this._gridOptions.columnApi.getColumnState();
+    return colState
+      .map(s => {
+      const def = this._gridOptions.columnApi.getColumn(s.colId).getColDef();
+      const label = def.headerName;
+      const name = def.checkboxSelection ? '__SELECTION__' : s.colId;
+      const colState = { label, name };
+      this.conditionalSet(colState, 'sort', s.sort);
+      this.conditionalSet(colState, 'sortIndex', s.sortIndex);
+      this.conditionalSet(colState, 'width', s.width);
+      this.conditionalSet(colState, 'pinned', s.pinned !== null);
+      this.conditionalSet(colState, 'hidden', s.hide);
+      const props = new Map();
+      props.set('sortable', def.sortable);
+      this.conditionalSet(colState, 'props', props);
+      return colState;
+    })
+      .filter(c => c.name !== '__SELECTION__' && c.name !== this.STATUS_COL_ID);
+  }
+  getSelection() {
+    return this._gridOptions.api.getSelectedRows();
+  }
+  addColumnMenuItem(item) {
+    const itemsNames = this._menuItems.map(i => i.name);
+    if (!itemsNames.includes(item.name)) {
+      this._menuItems.push(item);
+    }
+  }
+  quickFilter(term) {
+    if (term) {
+      const quickFilter = {
+        term,
+        fields: this._gridOptions.columnApi
+          .getColumns()
+          .filter(col => col.isVisible() && ![this.CHECK_BOX_COL_ID, this.STATUS_COL_ID, this.RECORD_ARCHIVE_COL_ID].includes(col.getColId()))
+          .map(col => col.getColId()),
+      };
+      this._dataSource.quickFilter = quickFilter;
+    }
+    else {
+      this._dataSource.quickFilter = undefined;
+    }
+  }
+  setSelectedIndex(index) {
+    var _a;
+    (_a = this._gridOptions.api.getDisplayedRowAtIndex(index)) === null || _a === void 0 ? void 0 : _a.setSelected(true);
+  }
+  hasFilterColumn(columnName) {
+    var _a;
+    const filterOptions = (_a = this._filteredColumns.get(columnName)) !== null && _a !== void 0 ? _a : [];
+    return filterOptions.map(item => item.check).includes(true);
+  }
+  buildColDef(source) {
+    var _a, _b, _c;
+    let tooltip = undefined;
+    const propSortable = StringUtils.getBooleanValue((_a = source.props) === null || _a === void 0 ? void 0 : _a.get('gridSortable'), true);
+    if ((_b = source.props) === null || _b === void 0 ? void 0 : _b.get('gridHeaderTooltip')) {
+      tooltip = (_c = source.props) === null || _c === void 0 ? void 0 : _c.get('gridHeaderTooltip');
+    }
+    else if (propSortable === false) {
+      tooltip = 'Coluna não pode ser ordenada';
+    }
+    return this._editionManager.configureColumn({
+      headerName: source.label,
+      field: source.name,
+      sortable: propSortable,
+      resizable: true,
+      headerComponent: 'ezGridCustomHeader',
+      headerComponentParams: {
+        tooltip: tooltip,
+        isSortable: propSortable,
+        hasFilter: () => this.hasFilterColumn(source.name),
+        showColumnFilter: (leftPosition, fromIcon) => this.showFilterColumn({ columnName: source.name, columnLabel: source.label, leftPosition, filteredOptions: this._filteredColumns.get(source.name), fromIcon }),
+      },
+      valueFormatter: params => {
+        if (params.value == undefined) {
+          return "";
+        }
+        if (params.value instanceof Promise) {
+          return "Carregando...";
+        }
+        if (this._dataUnit) {
+          return this._dataUnit.getFormattedValue(source.name, params.value);
+        }
+        return this.getFormatterByColumn(params, source);
+      },
+      cellStyle: this.getStyleByColumn(source),
+    });
+  }
+  getInitCellStyle() {
+    return {
+      'line-height': this.getRowHeight() - 1 + 'px',
+    };
+  }
+  getStyleByColumn(source) {
+    let cellStyle = this.getInitCellStyle();
+    switch (source === null || source === void 0 ? void 0 : source.userInterface) {
+      case UserInterface.DECIMALNUMBER:
+      case UserInterface.INTEGERNUMBER:
+        cellStyle['text-align'] = 'right';
+        break;
+      case UserInterface.DATE:
+      case UserInterface.DATETIME:
+      case UserInterface.TIME:
+        cellStyle['text-align'] = 'center';
+        break;
+      default:
+        cellStyle['text-align'] = 'left';
+    }
+    return cellStyle;
+  }
+  getFormatterByColumn(params, source) {
+    var _a;
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === 'OPTIONSELECTOR' && source.options) {
+      const prop = source === null || source === void 0 ? void 0 : source.options;
+      let options;
+      if (typeof prop === 'string') {
+        const parsed = JSON.parse(prop);
+        options = Object.keys(parsed).map(key => {
+          return { value: key, label: parsed[key] };
+        });
+      }
+      else {
+        options = prop;
+      }
+      let optionSelected;
+      options.forEach(option => {
+        if (option.value == params.value) {
+          optionSelected = option;
+        }
+      });
+      return optionSelected === null || optionSelected === void 0 ? void 0 : optionSelected.label;
+    }
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.SWITCH) {
+      if ((params === null || params === void 0 ? void 0 : params.value) === 'S' || (params === null || params === void 0 ? void 0 : params.value) === true || (params === null || params === void 0 ? void 0 : params.value) === 'true') {
+        return 'Sim';
+      }
+      else if ((params === null || params === void 0 ? void 0 : params.value) === 'N' || (params === null || params === void 0 ? void 0 : params.value) === false || (params === null || params === void 0 ? void 0 : params.value) === 'false') {
+        return 'Não';
+      }
+    }
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.SEARCH) {
+      if (((_a = params === null || params === void 0 ? void 0 : params.value) === null || _a === void 0 ? void 0 : _a.value) != undefined) {
+        return params.value.value + ' - ' + params.value.label;
+      }
+      else {
+        return params === null || params === void 0 ? void 0 : params.value;
+      }
+    }
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.DECIMALNUMBER) {
+      if (params.value != undefined) {
+        const precision = Number(source.props.get('precision')) || 2;
+        return NumberUtils.format(params.value.toString(), precision, precision);
+      }
+    }
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.DATE || (source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.DATETIME) {
+      if (params.value != undefined) {
+        return params.value.toLocaleDateString();
+      }
+    }
+    if ((source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.ELAPSEDTIME || (source === null || source === void 0 ? void 0 : source.userInterface) === UserInterface.TIME) {
+      if (!!params.value) {
+        const maskFormatter = new MaskFormatter("##:##");
+        const formattedValue = String(params.value).padStart(4, '0');
+        return maskFormatter.format(formattedValue);
+      }
+    }
+  }
+  onCallStateChange(type, e) {
+    const finished = !('finished' in e) || e['finished'];
+    if (finished && this._columnStateChangeCallback) {
+      let info = {};
+      let isUserChange = this.isUIEvent(e['source'], e['type']);
+      if (type === 'columnResize') {
+        info['column'] = { colId: e['column'].colId, actualWidth: e['column'].actualWidth };
+      }
+      info['isUserChange'] = isUserChange;
+      info['isElementResize'] = this.isElementResize(e);
+      this._columnStateChangeCallback(type, this.getColumnsState(), info);
+    }
+  }
+  onCellClicked(event) {
+    this._editionManager.verifyClickToEdition(event.api, {
+      rowIndex: event.rowIndex,
+      column: event.column,
+      rowPinned: undefined
+    });
+  }
+  isElementResize(e) {
+    return e['target'] && e['target'].getAttribute('ref') === 'eResize';
+  }
+  isUIEvent(source, type) {
+    let optionsArr = ['uiColumnMoved', 'uiColumnResized', 'uiColumnDragged', 'uiColumnExpanded', 'uiColumnSorted'];
+    if (type === 'dragStopped') {
+      return true;
+    }
+    if (source) {
+      return optionsArr.includes(source);
+    }
+    return false;
+  }
+  onSelectionChange(event) {
+    if (this._selectionChangeCallback) {
+      clearTimeout(this._selectionChangeDeboucing);
+      this._selectionChangeDeboucing = window.setTimeout(() => {
+        this._editionManager.proceedAutoSave();
+        if (this._dataUnit) {
+          if (event.context.selectionChangeQuietly) {
+            const selectionInfo = this._dataUnit;
+            this._selectionChangeCallback({
+              selection: selectionInfo.records,
+              selectionHeaderStatus: this.getSelectionHeaderStatus(),
+            });
+          }
+          else {
+            this._dataUnit.updatePageSelection(this._gridOptions.api.getSelectedRows().map((r) => r.__record__id__)).then(selectionInfo => {
+              this._selectionChangeCallback({
+                selection: selectionInfo.records,
+                selectionHeaderStatus: this.getSelectionHeaderStatus(),
+              });
+            });
+          }
+        }
+        else {
+          this._selectionChangeCallback({
+            selection: this._gridOptions.api.getSelectedRows(),
+            selectionHeaderStatus: this.getSelectionHeaderStatus(),
+          });
+        }
+      }, 0);
+    }
+  }
+  onRowDoubleClick(evt) {
+    if (this._doubleClickCallBack) {
+      this._doubleClickCallBack(evt.data);
+    }
+  }
+  conditionalSet(host, attribute, value) {
+    if (value !== null && value !== undefined && value !== false) {
+      host[attribute] = value;
+    }
+  }
+  getColumnWidth(cfgColumn) {
+    var _a, _b;
+    if (cfgColumn == undefined) {
+      return;
+    }
+    if (cfgColumn.customWidth != undefined) {
+      return cfgColumn.customWidth;
+    }
+    const field = (_a = this._dataUnit) === null || _a === void 0 ? void 0 : _a.getField(cfgColumn.name);
+    if ((field === null || field === void 0 ? void 0 : field.userInterface) === UserInterface.SEARCH) {
+      return this.DEFAULT_MAX_SIZE;
+    }
+    const labelSize = (((_b = field === null || field === void 0 ? void 0 : field.label) === null || _b === void 0 ? void 0 : _b.length) || 0) * this.DEFAULT_FONT_SIZE + this.DEFAULT_ICON_SIZE;
+    return labelSize > this.DEFAULT_MAX_SIZE ? this.DEFAULT_MAX_SIZE : labelSize;
+  }
+}