@sankhyalabs/core 6.1.0-ms.2 → 6.1.0

package/src/dataunit/DataUnit.ts

@@ -29,15 +29,12 @@ import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/Lo
 import SortingUtils from "../utils/SortingUtils.js";
 import ServiceCanceledException from "../exceptions/ServiceCanceledException.js";
 import SilentException from "../exceptions/SilentException.js";
-import { DataUnitEventOptions, DUActionInterceptor, HideFieldOptions, LoadDataParams, QuickFilter, Record, SavedRecord, SelectionMode, WaitingChange } from "./interfaces/dataUnit.js";
-import { Change } from "./Changes.js";
-import { SelectionInfo } from "./SelectionInfo.js";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
 */
 export default class DataUnit {
-
+    
     public static CHANGING_PAGE_LOADING_SOURCE = "CHANGING_PAGE_LOADING_SOURCE";
     public static ALL_RECORDS_SELECTION_SOURCE = "ALL_RECORDS_SELECTION_SOURCE";
     public static DEFAULT_DATAUNIT_NAME = "dataunit";
@@ -60,7 +57,7 @@ export default class DataUnit {
     private _cancelPagination: boolean = false;
     private _isMultipleEdition: boolean = false;
     private _fieldSourceValue: Map<string, string> = new Map<string, string>();
-
+    
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
@@ -103,9 +100,9 @@ export default class DataUnit {
     /**
      * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
      */
-    public release() {
+    public release(){
         DataUnitStorage.remove(this._name);
-        if (this._parentDataUnit) {
+        if(this._parentDataUnit){
             this._parentDataUnit.unsubscribe(this.onDataUnitParentEvent);
             this._parentDataUnit.removeChildDataunit(this._name);
         }
@@ -123,8 +120,8 @@ export default class DataUnit {
      * - Observers
      * - Sorting Providers
      */
-    public releaseCallbacks() {
-        if (!this._allowReleaseCallbacks) return;
+    public releaseCallbacks(){
+        if(!this._allowReleaseCallbacks) return;
 
         this._observers = new Map();
         this._filterProviders = new Map<string, FilterProvider>();
@@ -141,8 +138,8 @@ export default class DataUnit {
      * @param value - Valor da propriedade
      * 
      */
-    public addGlobalLoaderProp(name: string, value: string): void {
-        this.dispatchAction(Action.LOADING_PROPERTY_ADDED, { [name]: value });
+    public addGlobalLoaderProp(name: string, value: string):void{
+        this.dispatchAction(Action.LOADING_PROPERTY_ADDED, {[name]: value});
     }
 
     /**
@@ -150,11 +147,11 @@ export default class DataUnit {
      * 
      * @returns - Todas as propriedades desde o final do último loader.
      */
-    public getGlobalLoaderProps(): Map<string, string> {
+    public getGlobalLoaderProps(): Map<string, string>{
         return getLoadingProperties(this._stateManager) || new Map();
     }
 
-    public get dataUnitId(): string {
+    public get dataUnitId(): string{
         return this._uuid;
     }
 
@@ -170,7 +167,7 @@ export default class DataUnit {
      * Define se o dataUnit tem um recarregamento pendente.
      * @param isWaiting
      */
-    public setWaitingToReload(isWaiting: boolean) {
+    public setWaitingToReload(isWaiting: boolean){
         this._waitingToReload = isWaiting;
     }
 
@@ -200,7 +197,7 @@ export default class DataUnit {
      */
     public set isMultipleEdition(isMultipleEdition) {
         this._isMultipleEdition = isMultipleEdition;
-        this.dispatchAction(Action.MULTIPLE_EDITION_CHANGED, { isMultipleEdition });
+        this.dispatchAction(Action.MULTIPLE_EDITION_CHANGED, {isMultipleEdition});
     }
 
     /**
@@ -236,7 +233,7 @@ export default class DataUnit {
      * 
     */
     private onDataUnitParentEvent = (action: DataUnitAction) => {
-        switch (action.type) {
+        switch(action.type){
             case Action.SELECTION_CHANGED:
             case Action.NEXT_SELECTED:
             case Action.PREVIOUS_SELECTED:
@@ -245,7 +242,7 @@ export default class DataUnit {
             case Action.EDITION_CANCELED:
                 this.clearDataUnit();
                 const selectedRecord = this._parentDataUnit?.getSelectedRecord();
-                if (selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)) {
+                if(selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)){
                     this.loadData();
                 }
                 break;
@@ -281,15 +278,15 @@ export default class DataUnit {
     */
     private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext, checkLastFilter?: boolean, selectFirstRecord?: boolean): Promise<LoadDataResponse> {
 
-        if (checkLastFilter && this.isSameRequest(request)) {
-            const paginationInfo = this.getPaginationInfo();
-            if (paginationInfo) {
+        if(checkLastFilter && this.isSameRequest(request)){
+            const paginationInfo = getPaginationInfo(this._stateManager);
+            if(paginationInfo){
                 const response: LoadDataResponse = {
                     records: getRecords(this._stateManager),
-                    paginationInfo
+                    paginationInfo 
                 };
 
-                if (selectFirstRecord) {
+                if(selectFirstRecord){
                     this.requestSelectFirst(executionCtx);
                 }
 
@@ -303,21 +300,21 @@ export default class DataUnit {
                     this.dataLoader(this, request).then(
                         async response => {
                             await this.dispatchAction(
-                                Action.DATA_LOADED,
-                                { ...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord },
+                                Action.DATA_LOADED, 
+                                {...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord},
                                 executionCtx
                             );
 
                             await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
 
-                            if (selectFirstRecord) {
+                            if(selectFirstRecord){
                                 this.requestSelectFirst(executionCtx);
                             }
                             resolve(response);
                         }
                     ).catch(error => {
                         console.error(error);
-                        const { errorCode } = error;
+                        const {errorCode} = error;
                         this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                         fail(new ErrorException("Erro ao carregar registros", error, errorCode))
                     });
@@ -326,13 +323,13 @@ export default class DataUnit {
         });
     }
 
-    private requestSelectFirst(executionCtx?: ExecutionContext) {
+    private requestSelectFirst(executionCtx?: ExecutionContext){
         window.requestAnimationFrame(() => {
             this.selectFirst(executionCtx);
         })
     }
 
-    private isSameRequest(request: LoadDataRequest): boolean {
+    private isSameRequest(request: LoadDataRequest): boolean{
         const lastRequest = getCurrentRequest(this._stateManager);
         return ObjectUtils.objectToString(request) === ObjectUtils.objectToString(lastRequest || {});
     }
@@ -357,7 +354,7 @@ export default class DataUnit {
                             resolve(this.metadata);
                         }
                     ).catch(error => {
-                        const { errorCode } = error;
+                        const {errorCode} = error;
                         fail(new ErrorException("Erro ao carregar metadados", error, errorCode))
                     });
                 }
@@ -365,7 +362,7 @@ export default class DataUnit {
         }
     }
 
-    public async loadDataWithParams({ source, keepSelection, selectFirstRecord, executionCtx, checkLastFilter, quickFilter }: LoadDataParams): Promise<LoadDataResponse> {
+    public async loadDataWithParams({source, keepSelection, selectFirstRecord, executionCtx, checkLastFilter, quickFilter}: LoadDataParams): Promise<LoadDataResponse> {
         return await this.loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord, keepSelection);
     }
 
@@ -381,13 +378,13 @@ export default class DataUnit {
      * 
     */
     public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean, source?: string, selectFirstRecord?: boolean, keepSelection?: boolean): Promise<LoadDataResponse> {
-
+        
         await this.processLoadingLockers();
 
         if (this._parentDataUnit) {
             const parentRecord = this._parentDataUnit.getSelectedRecord();
-            if (parentRecord == undefined || this._parentDataUnit.isNewRecord(parentRecord.__record__id__)) {
-                if (this.records) {
+            if(parentRecord == undefined || this._parentDataUnit.isNewRecord(parentRecord.__record__id__)){
+                if(this.records){
                     this.clearDataUnit();
                 }
                 return Promise.resolve({
@@ -411,7 +408,7 @@ export default class DataUnit {
      * 
     */
     public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
-        if (this._pageSize === 0) {
+        if(this._pageSize === 0) {
             return;
         }
 
@@ -482,13 +479,13 @@ export default class DataUnit {
         return request;
     }
 
-    private async notifySavingData(executionCtx?: ExecutionContext): Promise<boolean> {
+    private async notifySavingData(executionCtx?: ExecutionContext): Promise<boolean>{
         const notifyPromises: Array<Promise<boolean>> = [];
         Array.from(this._childByName.values()).forEach(
             child => notifyPromises.push(child.notifySavingData(executionCtx))
         );
-
-        if (isDirty(this._stateManager)) {
+        
+        if(isDirty(this._stateManager)){
             notifyPromises.push(this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx));
         }
 
@@ -497,8 +494,8 @@ export default class DataUnit {
         }));
     }
 
-    private getBeforeSavePromisses(): Array<Promise<any> | undefined> {
-        let promises = getWaitingChangePromisses(this._stateManager) || [];
+    private getBeforeSavePromisses(): Array<Promise<any>|undefined>{
+        let promises = getWaitingChangePromisses(this._stateManager)||[];
         promises = promises.concat(this._savingLockers);
         return promises;
     }
@@ -516,18 +513,15 @@ export default class DataUnit {
         const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
 
         if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
-            const entry = blockingWaitingChanges.entries().next().value;
-            if (entry) {
-                const [_, waitingChange] = entry;
-                return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", waitingChange.waitmessage));
-            }
+            const [_, waitingChange] = blockingWaitingChanges.entries().next().value;
+            return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", (waitingChange as WaitingChange).waitmessage));
         } else {
             if (this.isDirty()) {
 
                 if (await this.notifySavingData(executionCtx)) {
                     const promisses = this.getBeforeSavePromisses();
                     return new Promise((resolve, fail) => {
-                        Promise.all(promisses).then(() => {
+                        Promise.all(promisses || []).then(() => {
                             this._savingLockers = [];
                             if (this.saveLoader) {
                                 const changes: Array<Change> = this.getAllChangesToSave();
@@ -540,21 +534,21 @@ export default class DataUnit {
                                     for (const [ownerDataUnitName, splittedRecords] of recordsByDataUnit) {
                                         const ownerDataUnit = DataUnitStorage.get(ownerDataUnitName);
                                         const changesByDataUnit = changes.filter(change => change.dataUnit === ownerDataUnitName);
-
-                                        if (ownerDataUnit) {
+                                        
+                                        if(ownerDataUnit){
                                             dispatchPromisses.push(ownerDataUnit.dispatchAction(Action.DATA_SAVED, { changes: changesByDataUnit, records: splittedRecords }, executionCtx));
                                         }
                                     }
                                     Promise.all(dispatchPromisses).then(() => resolve());
                                 }).catch(cause => {
-                                    const { errorCode } = cause;
+                                    const {errorCode} = cause;
                                     this.dispatchAction(Action.SAVING_ERROR);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
-                                    if (cause instanceof ServiceCanceledException) {
+                                    if(cause instanceof ServiceCanceledException){
                                         console.debug("Service canceled: " + cause.message);
                                         resolve();
-                                    }
-                                    if (cause instanceof SilentException) {
+                                    } 
+                                    if(cause instanceof SilentException){
                                         fail(cause);
                                         return;
                                     }
@@ -582,17 +576,17 @@ export default class DataUnit {
      * @returns - Mudanças realizadas no DataUnit atual
      * 
     */
-    public buildChangesToSave(): Array<Change> {
+    public buildChangesToSave(): Array<Change>{
         return getChangesToSave(this._name, this._stateManager);
     }
 
     public buildChangesToSaveFromChild(allChanges: Array<Change>, dataUnit: DataUnit): void {
-        dataUnit._childByName.forEach((dataUnitChild: DataUnit) => {
+        dataUnit._childByName?.forEach((dataUnitChild: DataUnit) => {
             if (dataUnitChild.isDirty()) {
-                allChanges.push(...getChangesToSave(dataUnitChild.name, dataUnitChild._stateManager));
-                this.buildChangesToSaveFromChild(allChanges, dataUnitChild);
+              allChanges.push(...getChangesToSave(dataUnitChild.name, dataUnitChild._stateManager));
+              this.buildChangesToSaveFromChild(allChanges, dataUnitChild);
             }
-        });
+          });
     }
 
     /**
@@ -623,18 +617,15 @@ export default class DataUnit {
     */
     public async removeSelectedRecords(buffered: boolean = false, silent: boolean = false): Promise<Array<string>> {
         const selection = this.getSelectionInfo();
-
-        if (selection.isAllRecords()) {
-            throw new Error("Exclusão remota não implementada.");
-        }
-
-        if (!selection.records || !selection.records.length) {
-            return Promise.resolve([]);
+        if (selection) {
+            if(selection.isAllRecords()){
+                throw new Error("Exclusão remota não implementada.");
+            }
+            const records = selection?.records as Array<Record> || [];
+            const recordIds = selection?.recordIds as Array<string> || [];
+            return this.removeRecords(recordIds, records, buffered, undefined, silent);
         }
-
-        const records = selection.records;
-        const recordIds = selection.recordIds as Array<string>;
-        return this.removeRecords(recordIds, records, buffered, undefined, silent);
+        return Promise.resolve([]);
     }
 
     /**
@@ -656,7 +647,7 @@ export default class DataUnit {
                 this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
             } else {
-                if (await this.dispatchAction(Action.REMOVING_RECORDS, { silent }, executionCtx)) {
+                if (await this.dispatchAction(Action.REMOVING_RECORDS, {silent}, executionCtx)) {
 
                     return new Promise((resolve, fail) => {
                         if (this.removeLoader) {
@@ -677,7 +668,7 @@ export default class DataUnit {
                                 }
                             ).catch(error => {
                                 this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
-                                const { errorCode } = error;
+                                const {errorCode} = error;
                                 fail(new ErrorException("Erro ao remover registros", error, errorCode))
                             });
                         }
@@ -736,11 +727,11 @@ export default class DataUnit {
         const descriptor = this.getField(fieldName);
         if (value == undefined) {
             value = this.getFieldValue(fieldName);
-        } else if (typeof value === "string" && descriptor?.dataType != DataType.TEXT) {
+        } else if (typeof value === "string" && descriptor?.dataType != DataType.TEXT){
             value = this.valueFromString(fieldName, value);
         }
 
-        if (value == undefined) {
+        if(value == undefined){
             return "";
         }
 
@@ -787,7 +778,7 @@ export default class DataUnit {
      * @param provider - FilterProvider que será removido.
      * 
     */
-    public removeFilterProvider(provider: FilterProvider): boolean {
+     public removeFilterProvider(provider: FilterProvider): boolean {
         return this._filterProviders.delete(this.getFielterProviderKey(provider));
     }
 
@@ -852,18 +843,18 @@ export default class DataUnit {
         return getMetadata(this._stateManager);
     }
 
-    /**
-    * 
-    * Obtém informações da ligação para um DataUnit filho.
-    * 
-    * @param name - Nome do DataUnit que se deseja.
-    * 
-    * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
-    * 
-    */
-    public getChildInfo(name: string): ChildDescriptor | undefined {
+     /**
+     * 
+     * Obtém informações da ligação para um DataUnit filho.
+     * 
+     * @param name - Nome do DataUnit que se deseja.
+     * 
+     * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
+     * 
+     */
+    public getChildInfo(name: string): ChildDescriptor|undefined {
         const children = this.metadata?.children;
-        if (children == undefined) {
+        if(children == undefined){
             return;
         }
 
@@ -969,41 +960,41 @@ export default class DataUnit {
     */
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectionInfo = this.getSelectionInfo();
-
-        if (selectionInfo.isAllRecords()) {
-            throw new Error("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
-        }
-
-        const selectedRecords = selectionInfo.records;
-
-        if (selectedRecords.length) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+        if (selectionInfo) {
+            if(selectionInfo.isAllRecords()){
+                throw new Error("Erro interno: Impossível copiar os registros selecionados pois a seleção atual é virtual.");
+            }
+            const selectedRecords = selectionInfo.records as Array<Record>;
+            if(selectedRecords){
+                
+                this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+            }
         }
     }
-
+    
     private getRecordsByDataUnit(records: Array<Record>): Map<string, Array<Record>> {
         const recordsMap = new Map<string, Array<Record>>();
-
+        
         records.forEach(record => {
             let { __owner__dataunit__name__: ownerDataUnitName } = record;
-
-            if (!ownerDataUnitName) {
+            
+            if(!ownerDataUnitName){
                 ownerDataUnitName = this.name;
             }
             let changes = recordsMap.get(ownerDataUnitName);
-
-            if (!changes) {
+            
+            if(!changes){
                 changes = [];
                 recordsMap.set(ownerDataUnitName, changes);
             }
 
             changes.push(record);
         });
-
+        
         return recordsMap;
     }
 
-    private getParentRecordId() {
+    private getParentRecordId(){
         const parentRecord = this._parentDataUnit?.getSelectedRecord();
         return parentRecord?.__record__id__;
     }
@@ -1045,27 +1036,27 @@ export default class DataUnit {
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
      *
      */
-    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?: DataUnitEventOptions): Promise<boolean> {
+    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?:DataUnitEventOptions): Promise<boolean> {
         const noRecordSelected = !this.hasNewRecord() && !this.getSelectedRecord();
 
         const suppressCreateNewRecord = options?.suppressCreateNewRecord;
 
-        if (noRecordSelected && suppressCreateNewRecord) return Promise.resolve(false);
+        if(noRecordSelected && suppressCreateNewRecord) return Promise.resolve(false);
 
-        if (noRecordSelected) await this.addRecord();
+        if(noRecordSelected) await this.addRecord();
 
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
 
-        if (this.areEquivalentValues(newValue, currentValue, typedValue)) {
+        if(this.areEquivalentValues(newValue, currentValue, typedValue)) {
             return Promise.resolve(false);
         }
 
-        if (newValue instanceof Promise) {
-            const promise: Promise<boolean> = new Promise(accept => {
+        if(newValue instanceof Promise){
+            const promise:Promise<boolean> = new Promise(accept => {
                 newValue.then(resolvedValue => {
                     this.dispatchAction(Action.DATA_RESOLVED, { [fieldName]: resolvedValue, records }, undefined);
-                    accept(this.setFieldValue(fieldName, resolvedValue, records, options));
+                    accept(this.setFieldValue(fieldName, resolvedValue, records,  options));
                 });
             });
             this._savingLockers.push(promise);
@@ -1083,8 +1074,8 @@ export default class DataUnit {
 
     private areEquivalentValues(newValue: any, currentValue: any, typedValue: any) {
         return !(newValue instanceof Promise)
-            && ObjectUtils.hasEquivalentProps(currentValue, typedValue)
-            && !this.isMultipleEdition;
+          && ObjectUtils.hasEquivalentProps(currentValue, typedValue)
+          && !this.isMultipleEdition;
     }
 
     /**
@@ -1108,7 +1099,7 @@ export default class DataUnit {
      * @param recordId - Indica qual registro está com os campos inválido.
      * 
     */
-    public savingCanceled(fields: Array<{ name: string, message: string }>, recordId: string): void {
+    public savingCanceled(fields: Array<{name: string, message: string}>, recordId: string): void {
         this.dispatchAction(Action.SAVING_CANCELED, { fields, recordId }, undefined);
     }
 
@@ -1132,7 +1123,7 @@ export default class DataUnit {
      * @param fieldName - Nome do campo.
      * 
     */
-    public getInvalidMessage(recordId: string, fieldName: string): string | undefined {
+    public getInvalidMessage(recordId: string, fieldName: string): string|undefined {
         return getInvalidFieldMessage(this._stateManager, fieldName, recordId);
     }
 
@@ -1166,6 +1157,7 @@ export default class DataUnit {
     public hasWaitingChanges(): boolean {
         const waitingChanges = getWaitingChanges(this._stateManager);
         return waitingChanges ? !!waitingChanges.size : false;
+        
     }
 
     /**
@@ -1218,7 +1210,7 @@ export default class DataUnit {
     public setSelection(selection: Array<string> | SelectionMode.ALL_RECORDS, executionCtx?: ExecutionContext): Promise<SelectionInfo> {
         return new Promise(resolve => {
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
-                .then(() => resolve(this.getSelectionInfo()));
+                .then(()=>resolve(this.getSelectionInfo()));
         });
     }
 
@@ -1229,7 +1221,7 @@ export default class DataUnit {
      * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
      * 
     */
-    public clearSelection(executionCtx?: ExecutionContext) {
+    public clearSelection(executionCtx?: ExecutionContext){
         this.setSelection([], executionCtx);
     }
 
@@ -1241,19 +1233,19 @@ export default class DataUnit {
      * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
      * @returns - Informações sobre a seleção.
     */
-    public updatePageSelection(selection?: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo | undefined> {
-        if (!selection) return Promise.resolve(this.getSelectionInfo());
+    public updatePageSelection(selection: Array<string>, executionCtx?: ExecutionContext): Promise<SelectionInfo|undefined>{
+        if(!selection) return Promise.resolve(this.getSelectionInfo());
 
         return new Promise(resolve => {
             const newSelection: Set<string> = new Set(selection);
 
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
-                .then(() => resolve(this.getSelectionInfo()));
+                .then(()=> resolve(this.getSelectionInfo()));
         });
     }
 
 
-    private updatePageSelectionAll(addRecords: boolean): Promise<SelectionInfo | undefined> {
+    private updatePageSelectionAll(addRecords: boolean): Promise<SelectionInfo|undefined>{
         return new Promise(resolve => {
             const newSelection: Set<string> = new Set<string>();
 
@@ -1261,10 +1253,10 @@ export default class DataUnit {
             cachedSelection.forEach(item => newSelection.add(item));
 
             const recordsIds = this.records.map(r => r.__record__id__);
-            recordsIds.forEach(id => addRecords ? newSelection.add(id) : newSelection.delete(id));
+            recordsIds.forEach(id => addRecords ? newSelection.add(id): newSelection.delete(id));
 
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) })
-                .then(() => resolve(this.getSelectionInfo()));
+              .then(()=> resolve(this.getSelectionInfo()));
         });
     }
 
@@ -1273,8 +1265,8 @@ export default class DataUnit {
      *
      * @returns - Informações sobre a seleção.
      */
-    public selectAllRecords(): Promise<SelectionInfo | undefined> {
-        return this.updatePageSelectionAll(true);
+     public selectAllRecords(): Promise<SelectionInfo|undefined>{
+         return this.updatePageSelectionAll(true);
     }
 
     /**
@@ -1282,9 +1274,9 @@ export default class DataUnit {
      *
      * @returns - Informações sobre a seleção.
      */
-    public unSelectAllRecords(): Promise<SelectionInfo | undefined> {
+     public unSelectAllRecords(): Promise<SelectionInfo|undefined>{
         return this.updatePageSelectionAll(false);
-    }
+     }
 
     /**
      * 
@@ -1292,13 +1284,13 @@ export default class DataUnit {
      * 
      * @returns - Objeto com informações como registros selecionados e seleção por critério.
      * 
-     **/
-    public getSelectionInfo(): SelectionInfo {
+     **/ 
+    public getSelectionInfo(): SelectionInfo{
         const selectionInfo: SelectionInfo = getSelectionInfo(this._stateManager);
         selectionInfo.getAllRecords = () => {
-
+           
             let records = this.allRecordsLoader?.(this) ?? [];
-
+            
             if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
                 const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
                 records = [...records].sort(sortingFunction);
@@ -1309,7 +1301,7 @@ export default class DataUnit {
 
         if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
             const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
-            selectionInfo.records.sort(sortingFunction)
+            selectionInfo.records?.sort(sortingFunction)
         }
 
         return selectionInfo;
@@ -1323,7 +1315,7 @@ export default class DataUnit {
      * 
     */
     public getSelectedRecord(): Record | undefined {
-        return getSelectedRecord(this._stateManager);
+       return getSelectedRecord(this._stateManager);
     }
 
     /**
@@ -1353,17 +1345,17 @@ export default class DataUnit {
      * 
      * 
     */
-    public async nextRecord(executionCtx?: ExecutionContext): Promise<void> {
-        if (!hasNext(this._stateManager)) {
-            if (hasMorePages(this._stateManager)) {
-                await this.nextPage({
-                    before: (act) => {
-                        if (executionCtx && executionCtx.before) {
+    public nextRecord(executionCtx?: ExecutionContext): void {
+        if(!hasNext(this._stateManager)){
+            if(hasMorePages(this._stateManager)){
+                this.nextPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
                             act = executionCtx.before(act);
                         }
                         return act;
                     },
-                    after: () => {
+                    after: act => {
                         this.selectFirst(executionCtx);
                     }
                 });
@@ -1380,17 +1372,17 @@ export default class DataUnit {
      * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
      * 
     */
-    public async previousRecord(executionCtx?: ExecutionContext): Promise<void> {
-        if (!hasPrevious(this._stateManager)) {
-            if (hasPreviousPages(this._stateManager)) {
-                await this.previousPage({
-                    before: (act) => {
-                        if (executionCtx && executionCtx.before) {
+    public previousRecord(executionCtx?: ExecutionContext): void {
+        if(!hasPrevious(this._stateManager)){
+            if(hasPreviousPages(this._stateManager)){
+                this.previousPage({
+                    before: act =>{
+                        if(executionCtx && executionCtx.before){
                             act = executionCtx.before(act);
                         }
                         return act;
                     },
-                    after: () => {
+                    after: act => {
                         this.selectLast(executionCtx);
                     }
                 });
@@ -1409,14 +1401,14 @@ export default class DataUnit {
      * 
     */
     public async cancelEdition(executionCtx?: ExecutionContext, fromParent?: boolean, silent: boolean = false): Promise<boolean> {
-        const cancelledAction = await this.dispatchAction(Action.EDITION_CANCELED, { fromParent, silent }, executionCtx);
-        for (const [, dataUnit] of this._childByName) {
-            if (dataUnit.isDirty()) {
-                dataUnit.cancelEdition(undefined, true, silent);
+            const cancelledAction = await this.dispatchAction(Action.EDITION_CANCELED, {fromParent, silent}, executionCtx);
+            for (const [, dataUnit] of this._childByName) {
+                if(dataUnit.isDirty()){
+                    dataUnit.cancelEdition(undefined, true, silent);
+                }
             }
-        }
-        return Promise.resolve(cancelledAction);
-
+            return Promise.resolve(cancelledAction);
+        
     }
 
     /**
@@ -1426,9 +1418,9 @@ export default class DataUnit {
      * @param ignoreChildren: Define se deverá ignorar alterações pendentes no DataUnit filho.
      * @returns Verdadeiro se existir alterações pendentes.
      * 
-    */
+    */ 
     public isDirty(ignoreChildren?: boolean): boolean {
-        if (ignoreChildren) return isDirty(this._stateManager);
+        if(ignoreChildren) return isDirty(this._stateManager);
 
         return isDirty(this._stateManager) || this.childrenIsDirty();
     }
@@ -1450,10 +1442,10 @@ export default class DataUnit {
      * 
      * @returns Verdadeiro se existir alterações pendentes em algum DataUnit detail.
      * 
-    */
-    private childrenIsDirty(): boolean {
-        for (let [_, dataUnitChild] of this._childByName) {
-            if (dataUnitChild.isDirty()) return true;
+    */ 
+    private childrenIsDirty():boolean {
+        for (let [key, dataUnitChild] of this._childByName) {
+            if(dataUnitChild.isDirty()) return true;
         }
         return false;
     }
@@ -1478,7 +1470,7 @@ export default class DataUnit {
     */
     public hasNext(): boolean {
         let result = hasNext(this._stateManager);
-        if (!result) {
+        if(!result){
             result = hasMorePages(this._stateManager);
         }
         return result;
@@ -1493,7 +1485,7 @@ export default class DataUnit {
     */
     public hasPrevious(): boolean {
         let result = hasPrevious(this._stateManager);
-        if (!result) {
+        if(!result){
             result = hasPreviousPages(this._stateManager);
         }
         return result;
@@ -1509,7 +1501,7 @@ export default class DataUnit {
     */
     public isNewRecord(recordId: string): boolean {
         const newRecords = getAddedRecords(this._stateManager);
-        if (newRecords && newRecords.length > 0) {
+        if(newRecords && newRecords.length > 0){
             const record = newRecords.find(newRecord => newRecord.__record__id__ === recordId);
             return record != undefined;
         }
@@ -1537,11 +1529,10 @@ export default class DataUnit {
     */
     public hasCopiedRecord(): boolean {
         const newRecords = getAddedRecords(this._stateManager);
-
-        if (newRecords == undefined) {
+        if(newRecords == undefined){
             return false;
         }
-        for (let record of newRecords) {
+        for(let record of newRecords){
             if (record['__record__source__id__'] != undefined) {
                 return true
             }
@@ -1617,7 +1608,7 @@ export default class DataUnit {
      * @returns - Verdadeiro se ação iniciada.
      * 
     */
-    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext, options?: DataUnitEventOptions): Promise<boolean> {
+    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext, options?:DataUnitEventOptions): Promise<boolean> {
         return new Promise(async resolve => {
             let action = new DataUnitAction(actionType, payload);
             if (executionCtx && executionCtx.before) {
@@ -1665,7 +1656,7 @@ export default class DataUnit {
      * @param action - Ações em execução no DataUnit.
      * 
     */
-    private doDispatchAction(action: DataUnitAction, options: DataUnitEventOptions = {}): void {
+    private doDispatchAction(action: DataUnitAction, options:DataUnitEventOptions = {}): void {
         this._stateManager.process(action);
         this?._parentDataUnit?.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
         this._observers.forEach(f => {
@@ -1685,7 +1676,7 @@ export default class DataUnit {
      * @param name - Nome do dataunit filho.
      * 
     */
-    public getChildDataunit(name: string) {
+    public getChildDataunit(name:string){
         const detail: DataUnit = new DataUnit(name, this);
         this._childByName.set(name, detail);
         return detail;
@@ -1698,10 +1689,10 @@ export default class DataUnit {
      * @param name - Nome do dataunit filho.
      * 
     */
-    public removeChildDataunit(name: string) {
+    public removeChildDataunit(name:string){
         this._childByName.delete(name);
     }
-
+    
     /**
      *  
      * Adiciona um novo observer no DataUnit.
@@ -1747,17 +1738,17 @@ export default class DataUnit {
      * @returns - Dados atualizados do registro selecionado.
      *      
     */
-    public reloadCurrentRecord(): Promise<Array<Record>> {
+    public reloadCurrentRecord(): Promise<Array<Record>>{        
         return new Promise(async (resolve, fail) => {
             const selection = getSelection(this._stateManager);
             await this.dispatchAction(Action.LOADING_RECORD, selection);
-
-            if (!this.recordLoader || !this.dataLoader) {
+            
+            if(!this.recordLoader || !this.dataLoader) {
                 await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 resolve([]);
                 return;
             }
-
+            
             this.recordLoader(this, selection).then(async response => {
                 await this.dispatchAction(Action.RECORD_LOADED, response)
                 await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
@@ -1765,7 +1756,7 @@ export default class DataUnit {
                 resolve(response);
             }).catch(async cause => {
                 await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
-                const { errorCode } = cause;
+                const {errorCode} = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
             });
         });
@@ -1789,7 +1780,7 @@ export default class DataUnit {
      * @returns - Lista de filtros.
      * 
     */
-    public getFilters(): Array<Filter> | undefined {
+    public getFilters(): Array<Filter> | undefined {        
         let filters: Array<Filter> | undefined = undefined;
         this._filterProviders.forEach(p => {
             const f = p.getFilter(this.name);
@@ -1806,18 +1797,18 @@ export default class DataUnit {
      * 
      * @returns - As informações de filtro e paginação.
      * 
-    */
+    */    
     public getLastLoadRequest(): LoadDataRequest | undefined {
         return getCurrentRequest(this._stateManager);
     }
-
+    
     /**
      * 
      * Obtém os filtros aplicados.
      * 
      * @returns - Lista de filtros.
      * 
-    */
+    */    
     public getAppliedFilters(): Array<Filter> | undefined {
         const { filters }: LoadDataRequest = getCurrentRequest(this._stateManager) || {};
         return filters
@@ -1829,16 +1820,12 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ser habilitado.
      * 
     */
-    public enableField(fieldName: string) {
+    public enableField(fieldName:string) {
         const fieldDescriptor = this.getField(fieldName);
 
-        if (!fieldDescriptor) {
-            return;
-        }
-
-        if (fieldDescriptor.readOnly) {
+        if(fieldDescriptor?.readOnly === true){
             fieldDescriptor.readOnly = false;
-            this.metadata = { ...this.metadata };
+            this.metadata = {...this.metadata};
         }
     }
 
@@ -1848,16 +1835,12 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar desabilitado.
      * 
     */
-    public disableField(fieldName: string) {
+    public disableField(fieldName:string) {
         const fieldDescriptor = this.getField(fieldName);
 
-        if (!fieldDescriptor) {
-            return;
-        }
-
-        if (!fieldDescriptor.readOnly) {
+        if(fieldDescriptor?.readOnly === false){
             fieldDescriptor.readOnly = true;
-            this.metadata = { ...this.metadata };
+            this.metadata = {...this.metadata};
         }
     }
 
@@ -1867,21 +1850,13 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar invisível.
      * 
     */
-    public hideField(fieldName: string, options?: HideFieldOptions) {
+    public hideField(fieldName:string, options:HideFieldOptions) {
         const fieldDescriptor = this.getField(fieldName);
 
-        if (!fieldDescriptor) {
-            return;
-        }
-
-        if (fieldDescriptor.visible) {
+        if(fieldDescriptor?.visible === true){
             fieldDescriptor.visible = false;
-
-            if (options) {
-                fieldDescriptor.properties = { ...fieldDescriptor.properties, visibleOnConfig: options.visibleOnConfig };
-            }
-
-            this.metadata = { ...this.metadata };
+            fieldDescriptor.properties = {...fieldDescriptor.properties, visibleOnConfig: options?.visibleOnConfig };
+            this.metadata = {...this.metadata};
         }
     }
 
@@ -1891,19 +1866,15 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar visível.
      * 
     */
-    public showField(fieldName: string) {
+    public showField(fieldName:string) {
         const fieldDescriptor = this.getField(fieldName);
 
-        if (!fieldDescriptor) {
-            return;
-        }
-
-        if (!fieldDescriptor.visible) {
+        if(fieldDescriptor?.visible === false){
             fieldDescriptor.visible = true;
-            this.metadata = { ...this.metadata };
+            this.metadata = {...this.metadata};
         }
     }
-
+       
     /**
      * 
      * Obtém todos os registros selecionados.
@@ -1919,7 +1890,7 @@ export default class DataUnit {
         console.warn("DataUnit: O método `getSelectedRecords` foi descontinuado. Use o método `getSelectionInfo`.");
         const selection = this.getSelectionInfo();
 
-        if (selection != undefined && selection.isAllRecords()) {
+        if(selection != undefined && selection.isAllRecords()){
             throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
         }
 
@@ -1942,11 +1913,11 @@ export default class DataUnit {
     public getSelection(): Array<string> {
         console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
         const selection = this.getSelectionInfo();
-        if (selection == undefined) {
+        if(selection == undefined){
             return [];
         }
 
-        if (selection.isAllRecords()) {
+        if(selection.isAllRecords()){
             throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
         }
 
@@ -1958,7 +1929,7 @@ export default class DataUnit {
      * 
      * @deprecated - metodo depreciado, utilizar o metodo addField
      */
-    public addStandAloneField(): void {
+    public addStandAloneField() : void {
         console.warn("metodo depreciado, para adicionar um campo standAlone, utilizar o metodo addField")
     }
 
@@ -1967,9 +1938,9 @@ export default class DataUnit {
      * 
      * @param field - Campo a ser adicionado.
      */
-    public addField(field: Omit<FieldDescriptor, 'standAlone'>): void {
-        const standAloneField = { ...field, standAlone: true };
-        this.metadata = { ...this.metadata, fields: [...this.metadata.fields, standAloneField] };
+    public addField(field: Omit<FieldDescriptor, 'standAlone'>) : void {
+        const standAloneField = {...field, standAlone: true};
+        this.metadata = {...this.metadata, fields: [...this.metadata.fields, standAloneField]};
     }
 
     /**
@@ -1977,16 +1948,16 @@ export default class DataUnit {
      * @returns Retorna uma função responsável por liberar o lock adicionado.
      */
     public addLoadingLocker(): Function {
-        let loadingLockerResolver = () => {};
+        let loadingLockerResolver;
 
         this._loadingLockers.push(new Promise((resolve) => {
             loadingLockerResolver = resolve;
         }));
-
-        return loadingLockerResolver;
+        
+        return loadingLockerResolver || Promise.resolve;
     }
 
-    public set allowReleaseCallbacks(allow: boolean) {
+    public set allowReleaseCallbacks(allow: boolean){
         this._allowReleaseCallbacks = allow;
     }
 
@@ -1994,19 +1965,19 @@ export default class DataUnit {
     /**
      * Adiciona um mapeamento de origem dos dados de um determinado campo
      */
-    public addSourceFieldValue(sourceFieldName: string, targetFieldName: string): void {
+    public addSourceFieldValue(sourceFieldName:string, targetFieldName:string): void{
         this._fieldSourceValue.set(sourceFieldName, targetFieldName);
     }
 
-    /**
-    * Retornar o campo de origem dos dados caso exista mapeamento
-    */
-    public getSourceFieldValue(sourceFieldName: string): string | undefined {
-        return this._fieldSourceValue.get(sourceFieldName);
+     /**
+     * Retornar o campo de origem dos dados caso exista mapeamento
+     */
+     public getSourceFieldValue(targetFieldName:string): string | undefined{
+        return this._fieldSourceValue.get(targetFieldName);
     }
 
-    private async processLoadingLockers() {
-        if (this._loadingLockers.length) {
+    private async processLoadingLockers(){
+        if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);
             this._loadingLockers = [];
         }
@@ -2014,16 +1985,200 @@ export default class DataUnit {
 
 }
 
-export {
-    Record,
-    Change,
-    SelectionInfo,
-    SelectionMode,
-    LoadDataParams,
-    DUActionInterceptor,
-    SavedRecord,
-    WaitingChange,
-    QuickFilter,
-    DataUnitEventOptions,
-    HideFieldOptions
-}
+export interface LoadDataParams {
+    quickFilter?: QuickFilter;
+    executionCtx?: ExecutionContext;
+    checkLastFilter?: boolean;
+    source?: string;
+    selectFirstRecord?: boolean;
+    keepSelection?: boolean
+}
+
+export interface DUActionInterceptor {
+    interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
+}
+
+export interface Record {
+    __record__id__: string;
+    __record__label__?: string;
+    __parent__record__id__?: string;
+    __owner__dataunit__name__?: string;
+    [key: string]: any;
+}
+
+export interface SavedRecord extends Record {
+    __old__id__?: string;
+}
+
+export enum ChangeOperation {
+    INSERT = "INSERT",
+    COPY = "COPY",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+}
+
+/***
+ * `Change`: Dados que representam uma alteração.
+ */
+export class Change {
+
+    public dataUnit: string;
+    public record: Record;
+    public sourceId: string | undefined;
+    public updatingFields: any;
+
+    private _operation: ChangeOperation;
+
+    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation, sourceId?: string) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.sourceId = sourceId;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+
+    /**
+     * 
+     * Obtém o tipo de operação que está sendo realizada.
+     * 
+     * @returns - Ação que está sendo executada.
+     * 
+     */
+    public get operation(): string {
+        return this._operation.toString();
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de inserção.
+     * 
+     * @returns - Verdadeiro se a operação for de inserção.
+     * 
+     */
+    public isInsert(): boolean {
+        return this._operation === ChangeOperation.INSERT;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de cópia.
+     * 
+     * @returns - Verdadeiro se a operação for de cópia.
+     * 
+     */
+    public isCopy(): boolean {
+        return this._operation === ChangeOperation.COPY;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de deleção.
+     * 
+     * @returns - Verdadeiro se a operação for de deleção.
+     * 
+     */
+    public isDelete(): boolean {
+        return this._operation === ChangeOperation.DELETE;
+    }
+
+    /**
+     * 
+     * Retorna se o DataUnit está em uma operação de atualização.
+     * 
+     * @returns - Verdadeiro se a operação for de atualização.
+     * 
+     */
+    public isUpdate(): boolean {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+}
+
+export interface WaitingChange {
+    waitmessage: string;
+    blocking: boolean;
+    promise?: Promise<any>;
+}
+
+export interface PageRequest {
+    limit: number;
+    offset: number;
+    quickFilter?: QuickFilter;
+}
+
+export interface QuickFilter {
+    term: string;
+    fields?: Array<string>;
+    filter?: Filter;
+}
+
+export interface PageResponse {
+    limit: number;
+    offset: number;
+    total: number;
+    hasMore: boolean;
+    records: Array<Record>;
+}
+
+export enum SelectionMode{
+    ALL_RECORDS = "ALL_RECORDS",
+    SOME_RECORDS = "SOME_RECORDS"
+}
+
+export class SelectionInfo{
+
+    public mode: SelectionMode;
+    public filters?: Array<Filter>;
+    public sort?: Array<Sort>;
+    public getAllRecords?: () => Array<Record> | undefined;
+    private _records: Array<Record>;
+    private _total?: number;
+    
+    constructor(records: Array<Record>, mode: SelectionMode = SelectionMode.SOME_RECORDS, total?:number, filters?: Array<Filter>, sort?: Array<Sort>){
+        this._records = records;
+        this._total = total;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+
+    public get records(): Array<Record> | undefined{
+        if(this.isAllRecords()){
+            if(this.getAllRecords != undefined){
+                return this.getAllRecords();
+            }
+            throw new Error("Erro interno: Impossível retornar os registros selecionados numa seleção virtual.");
+        }
+        return this._records;
+    }
+
+    public get recordIds(): Array<string> | undefined{
+
+        const records = this.records;
+
+        if(records == undefined){
+            return undefined;
+        }
+        return records.map(record => record.__record__id__);
+    }
+
+    public get length(): number{
+        if(this.isAllRecords()){
+            return this._total || 0;
+        }
+        return this.records == undefined ? 0 : (this.records as Array<Record>).length;
+    }
+
+    public isAllRecords(): boolean{
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+
+    public isEmpty(): boolean{
+        return this.length === 0;
+    }
+}
+
+export type DataUnitEventOptions = {[key:string]: any};
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};