@sankhyalabs/ezui 5.22.0-dev.20 → 5.22.0-dev.21

package/dist/custom-elements/index.js

@@ -513,7 +513,7 @@ class RecordValidationProcessor {
     this._validationSource = validationSource;
     this._validator = validator;
   }
-  validate() {
+  validate(isSaving = true) {
     return new Promise((accept, reject) => {
       const records = this._dataUnit.getModifiedRecords();
       for (let i = 0; i < records.length; i++) {
@@ -530,6 +530,11 @@ class RecordValidationProcessor {
           }
         }
         if (invalidResults.length > 0) {
+          if (!isSaving && invalidResults[0].invalidFields.length > 0) {
+            this._validationSource.markAsInvalid(invalidResults[0].invalidFields[0], record.__record__id__);
+            reject();
+            break;
+          }
           this.processValidationResult(invalidResults, record.__record__id__);
           reject();
           break;
@@ -561,6 +566,7 @@ class RecordValidationProcessor {
   processValidationResult(validationResult, recordId) {
     validationResult.forEach(invalidResult => {
       const invalidFields = invalidResult.invalidFields;
+      this._dataUnit.savingCanceled(invalidFields, recordId);
       if (invalidFields) {
         invalidFields.forEach(field => {
           this.markAsInvalid(field, recordId);
@@ -650,7 +656,7 @@ class DataBinder {
     this._recordValidatorProcessor = new RecordValidationProcessor(this._dataUnit, {
       getRequiredFields: () => this._formMetadata.getRequiredFields(),
       markAsInvalid: field => this.markInvalid(field),
-      getMessageForField: field => this.getErrorMessage(field)
+      getMessageForField: field => this.getErrorMessage(field),
     }, recordsValidator);
   }
   disconnectDataUnit() {
@@ -124456,6 +124462,73 @@ class DataSourceInterceptor {
 }
 
 class DataSource {
+  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) {
+    var _a, _b;
+    if (!this._options.enableGridInsert) {
+      this.handleRefresh(action);
+      return;
+    }
+    this.updateGridRowNodes((_b = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.records) !== null && _b !== void 0 ? _b : []);
+  }
+  /**
+   *  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.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(() => {
+      var _a;
+      const newRowIndex = ((_a = this._dataUnit.records) === null || _a === void 0 ? void 0 : _a.length) - 1;
+      this._controller.startEditionOnRowByIndex(newRowIndex);
+    }, 500);
+  }
   updateLoadedRecords(action) {
     const records = action.payload;
     if ((records === null || records === void 0 ? void 0 : records.length) > 0) {
@@ -124507,15 +124580,20 @@ class DataSource {
             this._options.onPaginationUpdate(this._dataUnit.getPaginationInfo());
           }
           break;
-        case Action.RECORDS_REMOVED:
+        case Action.RECORDS_ADDED:
+          this.handleRecordsAdded();
+          break;
         case Action.DATA_SAVED:
         case Action.EDITION_CANCELED:
+          this._controller.clearInvalidCells(action.type);
+          this.handleRefreshOrReload(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:
@@ -124525,6 +124603,9 @@ class DataSource {
         case Action.RECORD_LOADED:
           this.updateLoadedRecords(action);
           break;
+        case Action.SAVING_CANCELED:
+          this.handleSavingCanceled(action);
+          break;
       }
     };
     this._dataUnit = dataUnit;
@@ -124546,6 +124627,9 @@ class DataSource {
   setAutoFocus(autoFocus) {
     this._options.autoFocus = autoFocus;
   }
+  setEnableGridInsert(enable) {
+    this._options.enableGridInsert = enable;
+  }
   getRows(params) {
     if (this.needReload(params)) {
       this._lastLoadingParams = params;
@@ -125207,15 +125291,16 @@ class EzGridCustomCellRender extends EzCellRender {
 }
 
 class GridEditionManager {
-  constructor(dataUnit, useEnterLikeTab, recordsValidator, editionIsDisabled, customEditors, customRenders) {
+  constructor(dataUnit, useEnterLikeTab, recordsValidator, editionIsDisabled, customEditors, customRenders, enableContinuousInsert) {
     this._dataUnit = dataUnit;
     this._recordValidationProcessor = new RecordValidationProcessor(this._dataUnit, {
       getRequiredFields: () => this.getRequiredFields(),
-      markAsInvalid: () => { },
-      getMessageForField: () => null
+      markAsInvalid: (invalidField, recordId) => { this.setInvalidCell(invalidField, recordId); },
+      getMessageForField: () => null,
     }, recordsValidator);
     this._useEnterLikeTab = useEnterLikeTab;
     this._editionIsDisabled = editionIsDisabled;
+    this._enableContinuousInsert = enableContinuousInsert;
     this._customEditors = customEditors;
     this._customRenders = customRenders;
   }
@@ -125230,6 +125315,10 @@ class GridEditionManager {
     };
     return options;
   }
+  canContinuousInsert() {
+    var _a;
+    return this._enableContinuousInsert && (this._dataUnit.records.length - 1) === ((_a = this._lastCellEdited) === null || _a === void 0 ? void 0 : _a.rowIndex);
+  }
   proceedAutoSave() {
     if (!this._dataUnit.isDirty()) {
       this.saveSuccess();
@@ -125242,15 +125331,33 @@ class GridEditionManager {
     if (currentRercord == undefined) {
       return;
     }
+    this._invalidCell = undefined;
     this._recordValidationProcessor
-      .validate()
+      .validate(true)
       .then(() => {
       this._dataUnit.saveData()
-        .then(() => this.saveSuccess())
+        .then(() => {
+        if (this.canContinuousInsert()) {
+          this._dataUnit.addRecord();
+        }
+        else {
+          this.saveSuccess();
+        }
+      })
         .catch(reason => this.saveFail(reason));
     })
       .catch(reason => this.saveFail(reason));
   }
+  async recordValidate() {
+    if (!this._dataUnit.isDirty())
+      return;
+    try {
+      this._invalidCell = undefined;
+      await this._recordValidationProcessor.validate(false);
+    }
+    catch (error) { }
+    this._gridOptions.api.refreshCells({ force: true });
+  }
   navigateByEnterKey(keyboardEvent) {
     const backwards = keyboardEvent.shiftKey;
     if (this._useEnterLikeTab) {
@@ -125459,6 +125566,34 @@ class GridEditionManager {
   setCellRenders(customRenders) {
     this._customRenders = customRenders;
   }
+  setInvalidCell(invalidCell, recordId) {
+    this._invalidCell = { field: invalidCell, recordId };
+  }
+  getInvalidCell() {
+    return this._invalidCell;
+  }
+  clearInvalidCells(action) {
+    this._invalidCell = undefined;
+    if (action === Action.EDITION_CANCELED) {
+      this._isGridEdition = false;
+    }
+    else if (action === Action.DATA_SAVED && this.canContinuousInsert()) {
+      this._dataUnit.addRecord();
+    }
+  }
+  setEnableContinuousInsert(enable) {
+    this._enableContinuousInsert = enable;
+  }
+  hasInvalidField(fieldName, recordId) {
+    if (!this.hasInvalidCell())
+      return false;
+    return this._invalidCell.field.name === fieldName && this._invalidCell.recordId === recordId;
+  }
+  hasInvalidCell() {
+    if (!this._invalidCell || !this._invalidCell.field || !this._invalidCell.recordId)
+      return false;
+    return true;
+  }
 }
 class TargetEdition {
   constructor(rowIndex, column, backwards) {
@@ -125502,6 +125637,8 @@ class AgGridController {
     this._filteredColumns = new Map();
     this._filterColumnleftPosition = 0;
     this._customFormatters = new Map();
+    this._gridShowDom = false;
+    this.peddingExecutionsOnGridShow = [];
     this._enterprise = enterprise;
   }
   getGridConfig() {
@@ -125587,7 +125724,7 @@ class AgGridController {
       this._doubleClickCallBack = options.onDoubleClick;
       this._multipleSelection = options.allowMultipleSelection;
       this._dataUnit = options.dataUnit;
-      this._editionManager = new GridEditionManager(this._dataUnit, options.useEnterLikeTab, options.recordsValidator, options.editionIsDisabled, options.customEditors || this._customEditors, options.customRenders || this._customRenders);
+      this._editionManager = new GridEditionManager(this._dataUnit, options.useEnterLikeTab, options.recordsValidator, options.editionIsDisabled, options.customEditors || this._customEditors, options.customRenders || this._customRenders, options.enableContinuousInsert);
       this._statusResolver = options.statusResolver;
       if (this._dataUnit) {
         this._dataUnit.sortingProvider = this;
@@ -125607,6 +125744,9 @@ class AgGridController {
         defaultColDef: {
           headerClass: 'ez-grid__cell-header',
           cellClass: 'ez-grid__cell-body',
+          cellClassRules: {
+            'invalidValue': (params) => this._editionManager.hasInvalidField(params.colDef.field, params.data["__record__id__"]),
+          },
           cellStyle: {
             height: '100%'
           }
@@ -125646,6 +125786,23 @@ class AgGridController {
       }
       this._gridOptions.api.setHeaderHeight(this.getHeaderRowHeight());
       this._customFormatters = options.customFormatters;
+      const observerCallback = (entries) => {
+        entries.forEach(entry => {
+          if (entry.isIntersecting) {
+            this._gridShowDom = true;
+            this.peddingExecutionsOnGridShow.forEach(func => func());
+            this.peddingExecutionsOnGridShow = [];
+          }
+          else {
+            this._gridShowDom = false;
+          }
+        });
+      };
+      this.observer = new IntersectionObserver(observerCallback, {
+        root: null,
+        threshold: 0.1
+      });
+      this.observer.observe(container);
     }
   }
   processFormatterCellCallback(params) {
@@ -125836,10 +125993,16 @@ class AgGridController {
       throw new Error('Erro interno: Grid ainda não inicializado.');
     }
   }
-  updateRows() {
+  updateRows(rows) {
     if (this._grid === undefined) {
       throw new Error('Erro interno: Grid ainda não inicializado.');
     }
+    rows === null || rows === void 0 ? void 0 : rows.forEach(row => this.updateRowData(row));
+  }
+  updateRowData(row) {
+    const node = this._gridOptions.api.getRowNode(row[this._idAttribName]);
+    node.setData(Object.assign({}, row));
+    this._editionManager.recordValidate();
   }
   selectAll(quietly = false) {
     try {
@@ -125922,14 +126085,42 @@ class AgGridController {
         });
         r.setData(data);
       });
+      this._gridOptions.api.refreshCells({ force: true });
+      const invalidCell = this._editionManager.getInvalidCell();
+      if (invalidCell) {
+        const rowNode = this._gridOptions.api.getRowNode(invalidCell.recordId);
+        if (rowNode && invalidCell.field) {
+          this.startEdition(rowNode.rowIndex, this._gridOptions.columnApi.getColumn(invalidCell.field.name));
+        }
+      }
     }
   }
-  refresh() {
+  savingCanceled(fields, recordId) {
+    const displayedColumns = this._gridOptions.columnApi.getAllDisplayedColumns();
+    const rowIndex = this._gridOptions.api.getRowNode(recordId).rowIndex;
+    const columnFocus = displayedColumns.find(column => this.isColumnEditable(rowIndex, column) && fields.find(field => field.name === column.getColId()));
+    this.focusByCollAndRow(columnFocus, rowIndex);
+    this.startEdition(rowIndex, columnFocus);
+  }
+  refresh(scrollToSelectedRow = false) {
     if (this._grid === undefined) {
       throw new Error('Erro interno: Grid ainda não inicializado.');
     }
     this._gridOptions.api.refreshServerSide({ purge: true });
     this._options.onRefresh();
+    if (scrollToSelectedRow)
+      this.scrollToSelectedRow();
+  }
+  scrollToSelectedRow() {
+    const rowNode = this._gridOptions.api.getSelectedNodes();
+    if (!rowNode || rowNode.length === 0)
+      return;
+    if (this._gridShowDom) {
+      this._gridOptions.api.ensureNodeVisible(rowNode[0]);
+    }
+    else {
+      this.peddingExecutionsOnGridShow.push(() => this._gridOptions.api.ensureNodeVisible(rowNode[0]));
+    }
   }
   focusOnGridContainer() {
     this._container.setAttribute('tabindex', '-1');
@@ -125948,6 +126139,14 @@ class AgGridController {
     var _a;
     (_a = this._dataSource) === null || _a === void 0 ? void 0 : _a.setAutoFocus(autoFocus);
   }
+  setEnableGridInsert(enable) {
+    var _a;
+    (_a = this._dataSource) === null || _a === void 0 ? void 0 : _a.setEnableGridInsert(enable);
+  }
+  setEnableContinuousInsert(enable) {
+    var _a;
+    (_a = this._editionManager) === null || _a === void 0 ? void 0 : _a.setEnableContinuousInsert(enable);
+  }
   setFocusFirstRow() {
     const firstRow = this._gridOptions.api.getDisplayedRowAtIndex(0);
     if (firstRow) {
@@ -125963,9 +126162,38 @@ class AgGridController {
       this.setFocusOnRow(lastRow.rowIndex);
     }
   }
+  startEditionOnRowByIndex(rowIndex) {
+    const firstCol = this.getFirstEditableColl(rowIndex);
+    this.focusByCollAndRow(firstCol, rowIndex);
+    this.startEdition(rowIndex, firstCol);
+  }
+  startEdition(rowIndex, firstCol) {
+    this._gridOptions.api.clearRangeSelection();
+    this._gridOptions.api.addCellRange({ rowStartIndex: rowIndex, rowEndIndex: rowIndex, columns: [firstCol] });
+    this._gridOptions.api.setFocusedCell(rowIndex, firstCol);
+    this._gridOptions.api.startEditingCell({ rowIndex, colKey: firstCol });
+    const cellEditor = this._gridOptions.api.getCellEditorInstances()[0];
+    if (cellEditor) {
+      cellEditor.focusIn();
+    }
+  }
+  getFirstEditableColl(rowIndex) {
+    const displayedColumns = this._gridOptions.columnApi.getAllDisplayedColumns();
+    return displayedColumns.find(column => this.isColumnEditable(rowIndex, column));
+  }
+  isColumnEditable(rowIndex, column) {
+    if (column.getColDef().headerName === '' || rowIndex === -1)
+      return false;
+    const rowId = this._dataUnit.records[rowIndex][this._idAttribName];
+    const rowNode = this._gridOptions.api.getRowNode(rowId);
+    return column.isCellEditable(rowNode);
+  }
   setFocusOnRow(rowIndex) {
     let displayedColumns = this._gridOptions.columnApi.getAllDisplayedColumns();
-    let firstCell = displayedColumns.find(column => column.getColDef().headerName !== '');
+    let firstColl = displayedColumns.find(column => column.getColDef().headerName !== '');
+    this.focusByCollAndRow(firstColl, rowIndex);
+  }
+  focusByCollAndRow(firstCell, rowIndex) {
     this._gridOptions.api.ensureColumnVisible(firstCell);
     this._gridOptions.api.ensureIndexVisible(rowIndex);
     this._gridOptions.api.setFocusedCell(rowIndex, firstCell);
@@ -126345,6 +126573,15 @@ class AgGridController {
     this._editionManager.setCellRenders(customRenders);
     (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.api.redrawRows();
   }
+  clearInvalidCells(action) {
+    if (!this._editionManager)
+      return;
+    this._editionManager.clearInvalidCells(action);
+    this._gridOptions.api.refreshCells({ force: true });
+  }
+  destroy() {
+    this.observer.disconnect();
+  }
 }
 
 function enableSelectAll(total) {
@@ -126592,6 +126829,8 @@ const EzGrid$1 = class extends HTMLElement$1 {
     this.recordsValidator = undefined;
     this.canEdit = true;
     this.autoFocus = true;
+    this.enableGridInsert = false;
+    this.enableContinuousInsert = true;
   }
   /**
    * Aplica a definição de colunas.
@@ -126918,6 +127157,8 @@ const EzGrid$1 = class extends HTMLElement$1 {
       editionIsDisabled: () => !this.canEdit,
       customFormatters: this._customFormatters,
       autoFocus: this.autoFocus,
+      enableGridInsert: this.enableGridInsert,
+      enableContinuousInsert: this.enableContinuousInsert,
       onRefresh: () => {
         if (this.dataUnit) {
           this.setSelection(this.dataUnit.getSelectionInfo());
@@ -127010,6 +127251,8 @@ const EzGrid$1 = class extends HTMLElement$1 {
   }
   componentDidUpdate() {
     this._gridController.setAutoFocus(this.autoFocus);
+    this._gridController.setEnableGridInsert(this.enableGridInsert);
+    this._gridController.setEnableContinuousInsert(this.enableContinuousInsert);
     if (this.dataUnit) {
       this.setSelection(this.dataUnit.getSelectionInfo());
     }
@@ -132861,7 +133104,7 @@ const EzFileItem = /*@__PURE__*/proxyCustomElement(EzFileItem$1, [1,"ez-file-ite
 const EzFilterInput = /*@__PURE__*/proxyCustomElement(EzFilterInput$1, [1,"ez-filter-input",{"label":[1],"value":[1537],"enabled":[4],"errorMessage":[1537,"error-message"],"restrict":[1],"mode":[513],"asyncSearch":[516,"async-search"],"canShowError":[516,"can-show-error"]}]);
 const EzForm = /*@__PURE__*/proxyCustomElement(EzForm$1, [2,"ez-form",{"dataUnit":[1040],"config":[16],"recordsValidator":[16],"fieldToFocus":[1,"field-to-focus"],"onlyStaticFields":[4,"only-static-fields"],"_fieldsProps":[32]}]);
 const EzFormView = /*@__PURE__*/proxyCustomElement(EzFormView$1, [2,"ez-form-view",{"fields":[16],"selectedRecord":[16],"_customEditors":[32]}]);
-const EzGrid = /*@__PURE__*/proxyCustomElement(EzGrid$1, [6,"ez-grid",{"multipleSelection":[4,"multiple-selection"],"config":[1040],"selectionToastConfig":[16],"serverUrl":[1,"server-url"],"dataUnit":[16],"statusResolver":[16],"columnfilterDataSource":[16],"useEnterLikeTab":[4,"use-enter-like-tab"],"recordsValidator":[16],"canEdit":[4,"can-edit"],"autoFocus":[4,"auto-focus"],"_paginationInfo":[32],"_paginationChangedByKeyboard":[32],"_showSelectionCounter":[32],"_isAllSelection":[32],"_currentPageSelected":[32],"_selectionCount":[32],"_hasLeftButtons":[32],"_customFormatters":[32]},[[0,"ezSelectionChange","onSelectionChange"]]]);
+const EzGrid = /*@__PURE__*/proxyCustomElement(EzGrid$1, [6,"ez-grid",{"multipleSelection":[4,"multiple-selection"],"config":[1040],"selectionToastConfig":[16],"serverUrl":[1,"server-url"],"dataUnit":[16],"statusResolver":[16],"columnfilterDataSource":[16],"useEnterLikeTab":[4,"use-enter-like-tab"],"recordsValidator":[16],"canEdit":[4,"can-edit"],"autoFocus":[4,"auto-focus"],"enableGridInsert":[4,"enable-grid-insert"],"enableContinuousInsert":[4,"enable-continuous-insert"],"_paginationInfo":[32],"_paginationChangedByKeyboard":[32],"_showSelectionCounter":[32],"_isAllSelection":[32],"_currentPageSelected":[32],"_selectionCount":[32],"_hasLeftButtons":[32],"_customFormatters":[32]},[[0,"ezSelectionChange","onSelectionChange"]]]);
 const EzGuideNavigator = /*@__PURE__*/proxyCustomElement(EzGuideNavigator$1, [1,"ez-guide-navigator",{"open":[1540],"selectedId":[1537,"selected-id"],"items":[16],"tooltipResolver":[16],"filterText":[32]}]);
 const EzIcon = /*@__PURE__*/proxyCustomElement(EzIcon$1, [1,"ez-icon",{"size":[513],"href":[513],"iconName":[513,"icon-name"]}]);
 const EzList = /*@__PURE__*/proxyCustomElement(EzList$1, [1,"ez-list",{"dataSource":[1040],"listMode":[1,"list-mode"],"useGroups":[1540,"use-groups"],"ezDraggable":[1028,"ez-draggable"],"ezSelectable":[1028,"ez-selectable"],"itemSlotBuilder":[1040],"itemLeftSlotBuilder":[1040],"hoverFeedback":[1028,"hover-feedback"],"_listItems":[32],"_listGroupItems":[32]}]);

package/dist/esm/{RecordValidationProcessor-b00b8b77.js → RecordValidationProcessor-9c6cc267.js}

@@ -28,7 +28,7 @@ class RecordValidationProcessor {
     this._validationSource = validationSource;
     this._validator = validator;
   }
-  validate() {
+  validate(isSaving = true) {
     return new Promise((accept, reject) => {
       const records = this._dataUnit.getModifiedRecords();
       for (let i = 0; i < records.length; i++) {
@@ -45,6 +45,11 @@ class RecordValidationProcessor {
           }
         }
         if (invalidResults.length > 0) {
+          if (!isSaving && invalidResults[0].invalidFields.length > 0) {
+            this._validationSource.markAsInvalid(invalidResults[0].invalidFields[0], record.__record__id__);
+            reject();
+            break;
+          }
           this.processValidationResult(invalidResults, record.__record__id__);
           reject();
           break;
@@ -76,6 +81,7 @@ class RecordValidationProcessor {
   processValidationResult(validationResult, recordId) {
     validationResult.forEach(invalidResult => {
       const invalidFields = invalidResult.invalidFields;
+      this._dataUnit.savingCanceled(invalidFields, recordId);
       if (invalidFields) {
         invalidFields.forEach(field => {
           this.markAsInvalid(field, recordId);

package/dist/esm/ez-form.entry.js

@@ -1,6 +1,6 @@
 import { r as registerInstance, c as createEvent, h, f as forceUpdate, H as Host, g as getElement } from './index-baa5e267.js';
 import { DateUtils, Action, StringUtils, ApplicationContext, WaitingChangeException, DataUnitAction, DataUnit, ElementIDUtils } from '@sankhyalabs/core';
-import { b as buildFieldMetadata, R as RecordValidationProcessor } from './RecordValidationProcessor-b00b8b77.js';
+import { b as buildFieldMetadata, R as RecordValidationProcessor } from './RecordValidationProcessor-9c6cc267.js';
 import './ApplicationUtils-eaf91331.js';
 import './DialogType-54a62731.js';
 
@@ -248,7 +248,7 @@ class DataBinder {
     this._recordValidatorProcessor = new RecordValidationProcessor(this._dataUnit, {
       getRequiredFields: () => this._formMetadata.getRequiredFields(),
       markAsInvalid: field => this.markInvalid(field),
-      getMessageForField: field => this.getErrorMessage(field)
+      getMessageForField: field => this.getErrorMessage(field),
     }, recordsValidator);
   }
   disconnectDataUnit() {