@sankhyalabs/ezui 5.22.0-dev.11 → 5.22.0-dev.110

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

@@ -1,7 +1,94 @@
-import { Action, ObjectUtils } from '@sankhyalabs/core';
-import { EZ_GRID_LOADING_SOURCE } from "../../../../utils/constants";
+import { Action, ObjectUtils, UserInterface } from '@sankhyalabs/core';
+import { EZ_GRID_LOADING_SOURCE, PRESENTATION_COL_ID_PROP_NAME, PRESENTATION_FROM_COL_PROP_NAME } from "../../../../utils/constants";
 import { DataSourceInterceptor } from "./DataSourceInterceptor";
 export default class DataSource {
+  handleDataSaved(action) {
+    if (this._options) {
+      this._options.onPaginationUpdate(this._dataUnit.getPaginationInfo());
+    }
+    this._controller.clearInvalidCells();
+    this.handleRefreshOrReload(action);
+    this._controller.processContinuousInsert();
+    this._controller.showSelectionColumn();
+  }
+  handleEditionCanceled(action) {
+    if (this._options.enableGridInsert) {
+      this._controller.processEditionCanceled();
+    }
+    this.handleRefreshOrReload(action);
+    this._controller.showSelectionColumn();
+  }
+  handleSavingCanceled(action) {
+    var _a, _b, _c, _d;
+    if (!((_a = action.payload) === null || _a === void 0 ? void 0 : _a.fields) || !((_b = action.payload) === null || _b === void 0 ? void 0 : _b.recordId))
+      return;
+    this._controller.savingCanceled((_c = action.payload) === null || _c === void 0 ? void 0 : _c.fields, (_d = action.payload) === null || _d === void 0 ? void 0 : _d.recordId);
+  }
+  handleDataChanged(action) {
+    if (!this._options.enableGridInsert) {
+      this.handleRefresh(action);
+      return;
+    }
+    this.updateGridRowNodes(this.createRecordIdList(action));
+  }
+  createRecordIdList(action) {
+    var _a, _b;
+    if ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.records)
+      return (_b = action.payload) === null || _b === void 0 ? void 0 : _b.records;
+    return this._dataUnit.getSelectedRecord() ? [this._dataUnit.getSelectedRecord().__record__id__] : [];
+  }
+  /**
+   *  Nesse ponto, o registro já se encontra atualizado no DU,
+   *  basta então passar seu valor para que a garde possa atualizar sua linha.
+  */
+  updateGridRowNodes(recordIDList) {
+    const recordsToUpdate = recordIDList === null || recordIDList === void 0 ? void 0 : recordIDList.map(id => this.getRecordById(id));
+    this._controller.updateRows(recordsToUpdate);
+  }
+  getRecordById(recordId) {
+    return this._dataUnit.records.find(record => record['__record__id__'] === recordId);
+  }
+  /**
+   * Em caso de necessidade de reload (isWaitingToReload), eh preciso chamar o dataUnit.gotoPage, pois ele aplica tambem a ordenacao dos registros,
+   * enquanto que o _controller.refresh apenas recarrega os dados na ordem que atua.
+   */
+  handleRefreshOrReload(action) {
+    if (this._dataUnit.isWaitingToReload()) {
+      this.handleReload();
+      return;
+    }
+    this.handleRefresh(action);
+  }
+  handleReload() {
+    this._dataUnit.setWaitingToReload(false);
+    this._dataUnit.gotoPage(0);
+  }
+  handleRefresh(action) {
+    if (this.isSilentChange(action)) {
+      return;
+    }
+    this._controller.refresh(action.type === Action.DATA_SAVED);
+  }
+  handleRecordsAdded() {
+    if (this._options.enableGridInsert) {
+      this._controller.hideSelectionColumn();
+      this._controller.refresh();
+      this.focusOnNewRecord();
+    }
+  }
+  focusOnNewRecord() {
+    /**
+     * O SetTimeout eh utilizado pois é preciso aguardar que o novo registro seja renderizado na grade.
+     * Tentamos utilizar a api da grade para adicionar um event listener, porém na versão que utilizamos, não existe
+     * algo que resolva nosso cenário.
+     *
+     * Sugiro no futuro utilizar algo como o applyServerSideTransaction, porém será preciso lidar com os handlers
+     * e callbacks implementados no AgGridController e GridEditionManager.
+     */
+    setTimeout(() => {
+      this._controller.startEditionOnLastRow();
+    }, 1000);
+  }
   updateLoadedRecords(action) {
     const records = action.payload;
     if ((records === null || records === void 0 ? void 0 : records.length) > 0) {
@@ -28,12 +115,15 @@ export default class DataSource {
       return ((_b = action === null || action === void 0 ? void 0 : action.payload) === null || _b === void 0 ? void 0 : _b.silent) === true;
     }
   }
-  constructor(dataUnit, controller, options) {
+  constructor(dataUnit, controller, options, resolveLoading) {
+    var _a;
     this.RECORD_ARCHIVE = "__RECORD_ARCHIVE__";
     this.duObserver = (action) => {
+      var _a;
       switch (action.type) {
         case Action.METADATA_LOADED:
           this._controller.setColumnsDef(this.buildColumnDefs());
+          (_a = this._resolveLoading) === null || _a === void 0 ? void 0 : _a.call(this);
           break;
         case Action.LOADING_DATA:
           this._waitingForLoad = true;
@@ -53,15 +143,22 @@ export default class DataSource {
             this._options.onPaginationUpdate(this._dataUnit.getPaginationInfo());
           }
           break;
-        case Action.RECORDS_REMOVED:
+        case Action.RECORDS_ADDED:
+        case Action.RECORDS_COPIED:
+          this.handleRecordsAdded();
+          break;
         case Action.DATA_SAVED:
+          this.handleDataSaved(action);
+          break;
         case Action.EDITION_CANCELED:
+          this.handleEditionCanceled(action);
+          break;
         case Action.DATA_CHANGED:
         case Action.DATA_RESOLVED:
-          if (this.isSilentChange(action)) {
-            return;
-          }
-          this._controller.refresh();
+          this.handleDataChanged(action);
+          break;
+        case Action.RECORDS_REMOVED:
+          this.handleRefresh(action);
           break;
         case Action.SELECTION_CHANGED:
         case Action.NEXT_SELECTED:
@@ -71,14 +168,24 @@ export default class DataSource {
         case Action.RECORD_LOADED:
           this.updateLoadedRecords(action);
           break;
+        case Action.SAVING_CANCELED:
+          this.handleSavingCanceled(action);
+          break;
       }
     };
-    this._dataUnit = dataUnit;
-    this._controller = controller;
-    this._controller.setColumnsDef(this.buildColumnDefs());
-    this._options = options;
-    this._dataUnit.subscribe(this.duObserver);
-    this._dataUnit.addInterceptor(new DataSourceInterceptor(this._controller));
+    try {
+      this._resolveLoading = resolveLoading;
+      this._dataUnit = dataUnit;
+      this._controller = controller;
+      this._controller.setColumnsDef(this.buildColumnDefs());
+      this._options = options;
+      this._dataUnit.subscribe(this.duObserver);
+      this._dataUnit.addInterceptor(new DataSourceInterceptor(this._controller));
+    }
+    finally {
+      if (this._dataUnit.metadata)
+        (_a = this._resolveLoading) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
   }
   updateSelection() {
     const selectionInfo = this._dataUnit.getSelectionInfo();
@@ -92,6 +199,9 @@ export default class DataSource {
   setAutoFocus(autoFocus) {
     this._options.autoFocus = autoFocus;
   }
+  setEnableGridInsert(enable) {
+    this._options.enableGridInsert = enable;
+  }
   getRows(params) {
     if (this.needReload(params)) {
       this._lastLoadingParams = params;
@@ -119,27 +229,54 @@ export default class DataSource {
   destroy() {
     this._dataUnit.unsubscribe(this.duObserver);
   }
+  registryListeners() {
+    var _a, _b;
+    (_a = this._dataUnit) === null || _a === void 0 ? void 0 : _a.unsubscribe(this.duObserver);
+    (_b = this._dataUnit) === null || _b === void 0 ? void 0 : _b.subscribe(this.duObserver);
+  }
   buildColumnDefs() {
-    const gridConfig = this._controller.getGridConfig() || [];
-    const columnDefs = [];
-    if (this._dataUnit.metadata) {
-      this._dataUnit.metadata.fields.sort((a, b) => {
-        const indexA = gridConfig.findIndex(value => value.name === a.name);
-        const indexB = gridConfig.findIndex(value => value.name === b.name);
-        return indexA - indexB;
-      });
-      this._dataUnit.metadata.fields.forEach(f => {
-        var _a;
-        if (f.visible !== false && f.name !== this.RECORD_ARCHIVE) {
-          const props = new Map();
-          const properties = this._dataUnit.getField(f.name).properties;
-          for (const value in properties) {
-            props.set(value, properties[value]);
+    try {
+      const gridConfig = this._controller.getGridConfig() || [];
+      const columnDefs = [];
+      if (this._dataUnit.metadata) {
+        this._dataUnit.metadata.fields.sort((a, b) => {
+          const indexA = gridConfig.findIndex(value => value.name === a.name);
+          const indexB = gridConfig.findIndex(value => value.name === b.name);
+          return indexA - indexB;
+        });
+        this._dataUnit.metadata.fields.forEach(f => {
+          var _a, _b;
+          if (f.visible !== false && f.name !== this.RECORD_ARCHIVE) {
+            const props = new Map();
+            const properties = this._dataUnit.getField(f.name).properties;
+            for (const value in properties) {
+              props.set(value, properties[value]);
+            }
+            const col = { label: f.label, name: f.name, userInterface: f.userInterface, options: (_a = this._dataUnit.getField(f.name).properties) === null || _a === void 0 ? void 0 : _a.options, props };
+            columnDefs.push(col);
+            if (f.userInterface === UserInterface.SEARCHPLUS && ((_b = f.properties) === null || _b === void 0 ? void 0 : _b.DESCRIPTIONFIELD)) {
+              const descriptionCol = this.buildDescriptionColumn(f);
+              columnDefs.push(descriptionCol);
+              f.properties[PRESENTATION_COL_ID_PROP_NAME] = descriptionCol.name;
+            }
           }
-          columnDefs.push({ label: f.label, name: f.name, userInterface: f.userInterface, options: (_a = this._dataUnit.getField(f.name).properties) === null || _a === void 0 ? void 0 : _a.options, props });
-        }
-      });
+        });
+      }
+      return columnDefs;
+    }
+    catch (error) {
+      console.warn(error);
     }
-    return columnDefs;
+  }
+  buildDescriptionColumn(field) {
+    var _a, _b, _c, _d;
+    const props = new Map();
+    props.set(PRESENTATION_FROM_COL_PROP_NAME, field.name);
+    return {
+      label: `${(_a = field.properties) === null || _a === void 0 ? void 0 : _a.DESCRIPTIONFIELDLABEL} (${(_b = field.properties) === null || _b === void 0 ? void 0 : _b.DESCRIPTIONENTITY})`,
+      name: `${(_c = field.properties) === null || _c === void 0 ? void 0 : _c.ENTITYNAME}.${(_d = field.properties) === null || _d === void 0 ? void 0 : _d.DESCRIPTIONFIELD}`,
+      userInterface: UserInterface.SHORTTEXT,
+      props
+    };
   }
 }

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

@@ -1,5 +1,6 @@
 import { Action } from "@sankhyalabs/core";
 import { DISTINCT_FILTER_NAME_PREFIX, EZ_GRID_LOADING_SOURCE } from "../../../../utils/constants";
+import { DataUnit } from "@sankhyalabs/core";
 export class DataSourceInterceptor {
   constructor(controller) {
     this._controller = controller;
@@ -11,7 +12,7 @@ export class DataSourceInterceptor {
   interceptAction(action) {
     var _a;
     if (action.type === Action.LOADING_DATA) {
-      if (EZ_GRID_LOADING_SOURCE !== action.payload.source) {
+      if (EZ_GRID_LOADING_SOURCE !== action.payload.source && DataUnit.CHANGING_PAGE_LOADING_SOURCE !== action.payload.source) {
         action.payload.filters = ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.filters) !== undefined ? this.clearColumnFilter(action.payload.filters) : action.payload.filters;
         this._controller.clearFilter();
       }

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

@@ -1,53 +1,152 @@
-import { UserInterface } from "@sankhyalabs/core";
-import { KeyCode } from "ag-grid-community";
-import { RecordValidationProcessor } from "../../../../utils/validators/recordvalidator/RecordValidationProcessor";
-import EzCellEditor from "./editor/EzCellEditor";
-import EzGridCustomCellEditor from "./components/EzGridCustomCellEditor";
-import EzGridCustomCellRender from "./components/EzGridCustomCellRender";
+import { LockManager, LockManagerOperation, StringUtils, UserInterface } from '@sankhyalabs/core';
+import { KeyCode, } from "@ag-grid-community/core";
+import { RecordValidationProcessor } from '../../../../utils/validators/recordvalidator/RecordValidationProcessor';
+import EzCellEditor from './editor/EzCellEditor';
+import EzGridCustomCellEditor from './components/EzGridCustomCellEditor';
+import EzGridCustomCellRender from './components/EzGridCustomCellRender';
+import { DataBinder } from '../../../../utils';
+import { PRESENTATION_COL_ID_PROP_NAME } from '../../../../utils/constants';
 export default class GridEditionManager {
-  constructor(dataUnit, useEnterLikeTab, recordsValidator, editionIsDisabled, customEditors, customRenders) {
+  constructor(dataUnit, useEnterLikeTab, recordsValidator, editionIsDisabled, customEditors, customRenders, enableContinuousInsert, enableGridInsert, lockerId) {
+    this._inProgressChanges = [];
     this._dataUnit = dataUnit;
     this._recordValidationProcessor = new RecordValidationProcessor(this._dataUnit, {
       getRequiredFields: () => this.getRequiredFields(),
-      markAsInvalid: () => { },
-      getMessageForField: () => null
+      markAsInvalid: (invalidField, recordId) => { this.pushInvalidCell(invalidField, recordId); },
+      getMessageForField: () => null,
     }, recordsValidator);
     this._useEnterLikeTab = useEnterLikeTab;
     this._editionIsDisabled = editionIsDisabled;
+    this._enableContinuousInsert = enableContinuousInsert;
+    this._enableGridInsert = enableGridInsert;
     this._customEditors = customEditors;
     this._customRenders = customRenders;
+    this._lockerId = lockerId;
   }
   configureGrid(options) {
     this._gridOptions = options;
     options.readOnlyEdit = true;
     options.onCellEditRequest = evt => this.onCellEditRequest(evt);
+    options.onCellEditingStarted = async (evt) => {
+      var _a;
+      if (this._dataUnit.hasNewRecord()) {
+        this.handleCellEditingStartedRowAdd(evt);
+      }
+      else {
+        this._lastCellOpened = this._lastCellEdited = { rowIndex: evt.rowIndex, column: evt.column, rowPinned: undefined };
+      }
+      (_a = this._currentEditLock) === null || _a === void 0 ? void 0 : _a.call(this);
+      this._currentEditLock = LockManager.lock(this._lockerId, LockManagerOperation.TASKBAR_CLICK);
+    };
+    options.onCellEditingStopped = () => {
+      var _a;
+      (_a = this._currentEditLock) === null || _a === void 0 ? void 0 : _a.call(this);
+    };
     options.onCellKeyDown = evt => {
       if (evt.event && evt["column"]) {
         this.onCellKeyDown(evt);
       }
     };
+    options.isRowSelectable = (node) => this.isSelectableRow(node);
+    options.onCellFocused = () => this.lockFocusWhenAddRow();
     return options;
   }
-  proceedAutoSave() {
-    if (!this._dataUnit.isDirty()) {
-      this.saveSuccess();
+  updateCurrentEditorGuiValue(updatedRowValue) {
+    const editorInstances = this._gridOptions.api.getCellEditorInstances();
+    if (!editorInstances || !editorInstances.length)
+      return;
+    const currentEditor = editorInstances[0];
+    const fieldMetadata = currentEditor.getFieldMetadata();
+    const fieldName = fieldMetadata.name;
+    const value = updatedRowValue[fieldName];
+    currentEditor.setGuiValue(value);
+  }
+  lockFocusWhenAddRow() {
+    var _a, _b, _c, _d;
+    const api = this._gridOptions.api;
+    const newFocusCell = api.getFocusedCell();
+    const rowIndex = newFocusCell === null || newFocusCell === void 0 ? void 0 : newFocusCell.rowIndex;
+    const recordId = (_b = (_a = this._dataUnit.getAddedRecords()) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.__record__id__;
+    const rowNode = api.getRowNode(recordId);
+    if (!this._dataUnit.hasNewRecord() || rowIndex == (rowNode === null || rowNode === void 0 ? void 0 : rowNode.rowIndex)) {
       return;
     }
-    if (!this._isGridEdition || this._dataUnit.hasNewRecord()) {
+    const lastCell = (_d = (_c = this._lastCellOpened) !== null && _c !== void 0 ? _c : this._lastCellEdited) !== null && _d !== void 0 ? _d : this._lastCellClicked;
+    if ((lastCell === null || lastCell === void 0 ? void 0 : lastCell.rowIndex) < (rowNode === null || rowNode === void 0 ? void 0 : rowNode.rowIndex)) {
       return;
     }
-    const currentRercord = this._dataUnit.getSelectedRecord();
-    if (currentRercord == undefined) {
+    api.clearFocusedCell();
+    if (!lastCell || (rowNode === null || rowNode === void 0 ? void 0 : rowNode.rowIndex) == undefined) {
       return;
     }
-    this._recordValidationProcessor
-      .validate()
-      .then(() => {
-      this._dataUnit.saveData()
-        .then(() => this.saveSuccess())
-        .catch(reason => this.saveFail(reason));
-    })
-      .catch(reason => this.saveFail(reason));
+    lastCell.rowIndex = rowNode === null || rowNode === void 0 ? void 0 : rowNode.rowIndex;
+    this.focusOnCell(lastCell);
+  }
+  handleCellEditingStartedRowAdd(evt) {
+    var _a, _b, _c, _d, _e;
+    const nodeId = (_a = evt.node) === null || _a === void 0 ? void 0 : _a.id;
+    const addedRecordId = (_c = (_b = this._dataUnit.getAddedRecords()) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.__record__id__;
+    if (nodeId == addedRecordId) {
+      this._lastCellOpened = this._lastCellEdited = { rowIndex: evt.rowIndex, column: evt === null || evt === void 0 ? void 0 : evt.column, rowPinned: undefined };
+      return;
+    }
+    evt.api.stopEditing();
+    const rowIndex = (_d = evt.api.getRowNode(addedRecordId)) === null || _d === void 0 ? void 0 : _d.rowIndex;
+    this._lastCellOpened = this._lastCellEdited = { rowIndex: rowIndex, column: (_e = this._lastCellEdited) === null || _e === void 0 ? void 0 : _e.column, rowPinned: undefined };
+  }
+  isSelectableRow(node) {
+    if (!this._dataUnit.hasNewRecord()) {
+      return true;
+    }
+    if (!this._dataUnit.isNewRecord(node.id)) {
+      return false;
+    }
+    return true;
+  }
+  canContinuousInsert() {
+    var _a;
+    return this._enableContinuousInsert && (this._dataUnit.records.length - 1) === ((_a = this._lastCellEdited) === null || _a === void 0 ? void 0 : _a.rowIndex);
+  }
+  async proceedAutoSave() {
+    var _a;
+    //Aguarda outras promises entrarem na fila
+    await new Promise(resolve => setTimeout(resolve, 100));
+    if (this._inProgressChanges.length) {
+      await Promise.all((_a = this._inProgressChanges) === null || _a === void 0 ? void 0 : _a.map(({ promise }) => promise));
+    }
+    if (!this._dataUnit.isDirty()) {
+      this.saveSuccess();
+      return true;
+    }
+    const currentRecord = this._dataUnit.getSelectedRecord();
+    if (currentRecord == undefined) {
+      return true;
+    }
+    this.clearInvalidCells(false);
+    try {
+      await this._recordValidationProcessor.validate(true);
+      await this.saveDataUnit();
+      this.saveSuccess();
+      return true;
+    }
+    catch (reason) {
+      this.saveFail(reason);
+      return false;
+    }
+  }
+  async saveDataUnit() {
+    await this._dataUnit.saveData();
+    return true;
+  }
+  async recordValidate() {
+    if (!this._dataUnit.isDirty())
+      return;
+    try {
+      this.clearInvalidCells(false);
+      await this._recordValidationProcessor.validate(false);
+    }
+    catch (error) { }
+    this._gridOptions.api.refreshCells({ force: true });
   }
   navigateByEnterKey(keyboardEvent) {
     const backwards = keyboardEvent.shiftKey;
@@ -71,6 +170,13 @@ export default class GridEditionManager {
     return { ezCellEditor: EzCellEditor };
   }
   verifyClickToEdition(api, cellClicked) {
+    var _a, _b;
+    const selectedRecordID = (_a = this._dataUnit.getSelectedRecord()) === null || _a === void 0 ? void 0 : _a.__record__id__;
+    if (this._dataUnit.hasNewRecord() && selectedRecordID) {
+      const dataUnitRecordIndex = (_b = api.getRowNode(selectedRecordID)) === null || _b === void 0 ? void 0 : _b.rowIndex;
+      if (dataUnitRecordIndex != cellClicked.rowIndex)
+        return;
+    }
     if (this.isSecondClick(cellClicked)) {
       api.startEditingCell({ rowIndex: cellClicked.rowIndex, colKey: cellClicked.column.getColId() });
     }
@@ -78,8 +184,13 @@ export default class GridEditionManager {
   }
   configureColumn(col) {
     col.cellEditor = 'ezCellEditor';
-    col.editable = params => this.canEdit(params);
+    if (col.editable != false) {
+      col.editable = params => this.canEdit(params);
+    }
     col.suppressKeyboardEvent = (params) => {
+      if (params.event.key === KeyCode.ESCAPE && params.editing) {
+        return this._dataUnit.isDirty();
+      }
       return params.event.key === KeyCode.ENTER;
     };
     col.cellEditorSelector = (params) => {
@@ -109,10 +220,21 @@ export default class GridEditionManager {
     return col;
   }
   getRequiredFields() {
-    return this._gridOptions.columnApi.getAllDisplayedColumns().filter(c => {
-      const fieldDefinition = this._dataUnit.getField(c.getColId());
-      return fieldDefinition && fieldDefinition.required;
-    }).map(c => c.getColId());
+    const formRequiredFields = this.getFormRequiredFields();
+    return this._gridOptions.columnApi.getAllDisplayedColumns()
+      .filter(column => {
+      const fieldDefinition = this._dataUnit.getField(column.getColId());
+      return (fieldDefinition && fieldDefinition.required) || formRequiredFields.includes(column.getColId());
+    })
+      .map(column => column.getColId());
+  }
+  getFormRequiredFields() {
+    const formRequiredFields = [];
+    const dataBinders = DataBinder.getDataBindersByDataUnit(this._dataUnit);
+    dataBinders.forEach(dataBinder => {
+      formRequiredFields.push(...dataBinder.getFormRequiredFields());
+    });
+    return formRequiredFields;
   }
   saveSuccess() {
     var _a;
@@ -125,18 +247,20 @@ export default class GridEditionManager {
     this._isGridEdition = false;
   }
   saveFail(reason) {
-    this.focusOnCell(this._lastCellEdited);
+    var _a;
+    this.focusOnCell((_a = this._lastCellOpened) !== null && _a !== void 0 ? _a : this._lastCellEdited);
     this._isGridEdition = false;
     if (reason) {
-      Promise.reject(reason);
+      throw reason;
     }
   }
   focusOnCell(cell) {
+    var _a;
     if (cell == undefined) {
       return;
     }
     const { rowIndex, column } = cell;
-    this._gridOptions.api.getDisplayedRowAtIndex(rowIndex).setSelected(true, true);
+    (_a = this._gridOptions.api.getDisplayedRowAtIndex(rowIndex)) === null || _a === void 0 ? void 0 : _a.setSelected(true, true);
     this._gridOptions.api.clearRangeSelection();
     this._gridOptions.api.addCellRange({ rowStartIndex: rowIndex, rowEndIndex: rowIndex, columns: [column] });
     this._gridOptions.api.startEditingCell({ colKey: column.getColId(), rowIndex });
@@ -176,9 +300,10 @@ export default class GridEditionManager {
       }
     }
     else {
+      const actualRowIndex = rowIndex;
       rowIndex = rowIndex + 1;
       if (rowIndex >= this._dataUnit.records.length) {
-        rowIndex = 0;
+        rowIndex = !this._enableGridInsert ? 0 : actualRowIndex;
       }
     }
     this._targetEditionCell = new TargetEdition(rowIndex, column, true);
@@ -191,6 +316,9 @@ export default class GridEditionManager {
     this.moveEditionVertically(api, 1);
   }
   moveEditionVertically(api, offset) {
+    if (this._dataUnit.hasNewRecord() && this._isGridEdition) {
+      return;
+    }
     const editionCell = api.getEditingCells()[0];
     if (!editionCell) {
       return;
@@ -235,28 +363,101 @@ export default class GridEditionManager {
     return true;
   }
   onCellEditRequest(event) {
-    const fieldName = event.colDef.field;
+    var _a;
     const value = event.newValue;
-    if (event.oldValue != value) {
-      if (value instanceof Promise) {
-        const fieldDescriptor = this._dataUnit.getField(event.colDef.colId);
-        event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: (fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.userInterface) === UserInterface.SEARCH ? value : event.oldValue }));
-        value.then(resolved => event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: resolved })));
-      }
-      else {
-        event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: value }));
-      }
+    if (event.oldValue == value) {
+      (_a = this._currentEditLock) === null || _a === void 0 ? void 0 : _a.call(this);
+      return;
+    }
+    if (value instanceof Promise) {
+      const progressChange = {
+        promise: undefined,
+        resolve: () => { }
+      };
+      progressChange.promise = new Promise((resolve) => {
+        progressChange.resolve = resolve;
+      });
+      this._inProgressChanges.push(progressChange);
+      this.handlePromiseValue(event, value);
+      return;
+    }
+    this.updateCellValue(event, value);
+  }
+  async handlePromiseValue(event, value) {
+    const fieldName = event.colDef.field;
+    const fieldDescriptor = this._dataUnit.getField(event.colDef.colId);
+    const initialValue = (fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.userInterface) === UserInterface.SEARCH ? value : event.oldValue;
+    event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: initialValue }));
+    const resolved = await value;
+    return this.updateCellValue(event, resolved);
+  }
+  async updateCellValue(event, newValue) {
+    var _a, _b, _c, _d;
+    const fieldName = event.colDef.field;
+    const newData = { [fieldName]: newValue };
+    const descriptionColName = (_b = (_a = this._dataUnit.getField(fieldName)) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b[PRESENTATION_COL_ID_PROP_NAME];
+    if (!StringUtils.isEmpty(descriptionColName)) {
+      newData[descriptionColName] = newValue === null || newValue === void 0 ? void 0 : newValue.label;
+    }
+    event.node.setData(Object.assign(Object.assign({}, event.data), { newData }));
+    (_c = this._currentEditLock) === null || _c === void 0 ? void 0 : _c.call(this);
+    if (event.oldValue !== newValue) {
       this._isGridEdition = true;
-      this._dataUnit.setFieldValue(fieldName, value, [event.data.__record__id__]);
+      await this._dataUnit.setFieldValue(fieldName, newValue, [event.data.__record__id__], { suppressCreateNewRecord: true });
       this._lastCellEdited = { rowIndex: event.rowIndex, column: event.column, rowPinned: undefined };
     }
+    (_d = this._inProgressChanges) === null || _d === void 0 ? void 0 : _d.forEach(({ resolve }) => resolve(newValue));
   }
   setCellEditors(customEditors) {
+    var _a;
     this._customEditors = customEditors;
+    (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.api.stopEditing();
   }
   setCellRenders(customRenders) {
     this._customRenders = customRenders;
   }
+  pushInvalidCell(invalidField, recordId) {
+    this._invalidCells.push({ field: invalidField, recordId });
+    this._nextInvalidCell = this._invalidCells[0];
+  }
+  getInvalidCells() {
+    return this._invalidCells;
+  }
+  getNextInvalidCell() {
+    return this._nextInvalidCell;
+  }
+  async processContinuousInsert() {
+    if (!this.canContinuousInsert())
+      return;
+    this._dataUnit.addRecord();
+  }
+  clearInvalidCells(stopEdition) {
+    this._invalidCells = [];
+    this._nextInvalidCell = undefined;
+    if (stopEdition) {
+      this._isGridEdition = false;
+    }
+  }
+  setEnableContinuousInsert(enable) {
+    this._enableContinuousInsert = enable;
+  }
+  hasInvalidField(fieldName, recordId) {
+    if (!this.hasInvalidCell())
+      return false;
+    this._nextInvalidCell = this._invalidCells[0];
+    const containsFieldName = this._nextInvalidCell.field.name === fieldName;
+    const containsRecordId = this._nextInvalidCell.recordId === recordId;
+    return containsFieldName && containsRecordId;
+  }
+  hasInvalidCell() {
+    var _a, _b, _c;
+    const hasInvalidCell = ((_a = this._invalidCells) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    const hasField = (_b = this._invalidCells) === null || _b === void 0 ? void 0 : _b.filter(invalidCell => { invalidCell.field; });
+    const hasRecordId = (_c = this._invalidCells) === null || _c === void 0 ? void 0 : _c.filter(invalidCell => { invalidCell.recordId; });
+    if (!hasInvalidCell || !hasField || !hasRecordId)
+      return false;
+    return true;
+  }
 }
 class TargetEdition {
   constructor(rowIndex, column, backwards) {