@sankhyalabs/core 5.20.0-dev.8 → 5.20.0-dev.81

package/src/dataunit/DataUnit.ts

@@ -26,6 +26,9 @@ import { v4 as uuid } from "uuid";
 import { DataUnitStorage } from "./DataUnitStorage.js";
 import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/InvalidFieldsSlice.js";
 import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/LoadingProperties.js";
+import SortingUtils from "../utils/SortingUtils.js";
+import ServiceCanceledException from "../exceptions/ServiceCanceledException.js";
+import SilentException from "../exceptions/SilentException.js";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
@@ -33,27 +36,32 @@ import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/Lo
 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";
 
     private _uuid: string;
     private _name: string;
-    private _observers: Array<(action: DataUnitAction) => void>;
+    private _observers: Map<string, (action: DataUnitAction, options?: DataUnitEventOptions) => void>;
     private _sortingProvider?: SortingProvider;
     private _filterProviders: Map<string, FilterProvider>;
     private _stateManager: StateManager;
-    private _interceptors: Array<DUActionInterceptor>;
+    private _interceptors: Map<string, DUActionInterceptor>;
     private _pageSize: number;
     private _childByName = new Map<string, DataUnit>();
     private _parentDataUnit: DataUnit | undefined;
     private _loadingLockers: Promise<void>[];
     private _savingLockers: Promise<any>[] = [];
     private _defaultSorting: Array<Sort>;
+    private _allowReleaseCallbacks: boolean;
+    private _waitingToReload: boolean = false;
+    private _cancelPagination: boolean = false;
     
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
     public recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
+    public allRecordsLoader?: (dataUnit: DataUnit) => Array<Record> | undefined;
 
     constructor(name: string = DataUnit.DEFAULT_DATAUNIT_NAME, parentDataUnit?: DataUnit) {
         this._uuid = uuid()
@@ -75,11 +83,12 @@ export default class DataUnit {
                 SnapshotReducer
             ]
         );
-        this._observers = [];
+        this._observers = new Map();
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
         this._defaultSorting = [];
-        this._interceptors = [];
+        this._allowReleaseCallbacks = true;
+        this._interceptors = new Map();
         this._parentDataUnit = parentDataUnit;
         this._parentDataUnit?.subscribe(this.onDataUnitParentEvent);
         this._loadingLockers = [];
@@ -110,10 +119,12 @@ export default class DataUnit {
      * - Sorting Providers
      */
     public releaseCallbacks(){
-        this._observers = [];
+        if(!this._allowReleaseCallbacks) return;
+
+        this._observers = new Map();
         this._filterProviders = new Map<string, FilterProvider>();
         this._sortingProvider = undefined;
-        this._interceptors = [];
+        this._interceptors = new Map();
     }
 
     /**
@@ -142,6 +153,36 @@ export default class DataUnit {
         return this._uuid;
     }
 
+
+    /**
+     * Retorna se o dataUnit está com recarregamento pendente.
+     */
+    public isWaitingToReload(): boolean {
+        return this._waitingToReload;
+    }
+
+    /**
+     * Define se o dataUnit tem um recarregamento pendente.
+     * @param isWaiting
+     */
+    public setWaitingToReload(isWaiting: boolean){
+        this._waitingToReload = isWaiting;
+    }
+
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    public get cancelPagination(): boolean {
+        return this._cancelPagination;
+    }
+
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    public set cancelPagination(cancelPagination: boolean) {
+        this._cancelPagination = cancelPagination;
+    }
+
     /**
      * 
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -180,6 +221,8 @@ export default class DataUnit {
             case Action.NEXT_SELECTED:
             case Action.PREVIOUS_SELECTED:
             case Action.DATA_LOADED:
+            case Action.RECORDS_ADDED:
+            case Action.EDITION_CANCELED:
                 this.clearDataUnit();
                 const selectedRecord = this._parentDataUnit?.getSelectedRecord();
                 if(selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)){
@@ -241,10 +284,10 @@ export default class DataUnit {
                         async response => {
                             await this.dispatchAction(
                                 Action.DATA_LOADED, 
-                                {...response, keepSelection: request.keepSelection, filters: request.filters},
+                                {...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord},
                                 executionCtx
                             );
-                            
+
                             await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
 
                             if(selectFirstRecord){
@@ -302,6 +345,10 @@ export default class DataUnit {
         }
     }
 
+    public async loadDataWithParams({source, keepSelection, selectFirstRecord, executionCtx, checkLastFilter, quickFilter}: LoadDataParams): Promise<LoadDataResponse> {
+        return await this.loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord, keepSelection);
+    }
+
     /**
      * 
      * Carrega os registros do DataUnit.
@@ -313,20 +360,23 @@ export default class DataUnit {
      * @returns - Registros requisitados.
      * 
     */
-    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean, source?: string, selectFirstRecord?: boolean): Promise<LoadDataResponse> {
+    public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext, checkLastFilter?: boolean, source?: string, selectFirstRecord?: boolean, keepSelection?: boolean): Promise<LoadDataResponse> {
         
         await this.processLoadingLockers();
 
-        if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
+        if (this._parentDataUnit) {
+            const parentRecord = this._parentDataUnit.getSelectedRecord();
+            if(parentRecord == undefined || this._parentDataUnit.isNewRecord(parentRecord.__record__id__)){
                 if(this.records){
                     this.clearDataUnit();
                 }
                 return Promise.resolve({
                     records: []
                 });
+            }
         }
 
-        const loadDataRequest = this.getLoadDataRequest(quickFilter, source);
+        const loadDataRequest = this.getLoadDataRequest(quickFilter, source, keepSelection);
         return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter, selectFirstRecord);
     }
 
@@ -336,11 +386,14 @@ export default class DataUnit {
      * 
      * @param page - Número da página desejada.
      * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
-     * 
+     *
      * @returns - Registros da página desejada.
      * 
     */
     public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
+        if(this._pageSize === 0) {
+            return;
+        }
 
         let request = getCurrentRequest(this._stateManager);
 
@@ -388,12 +441,13 @@ export default class DataUnit {
         return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
     }
 
-    private getLoadDataRequest(quickFilter?: QuickFilter, source?: string): LoadDataRequest {
+    private getLoadDataRequest(quickFilter?: QuickFilter, source?: string, keepSelection?: boolean): LoadDataRequest {
         const request: LoadDataRequest = {
             filters: quickFilter?.filter ? [quickFilter.filter] : this.getFilters(),
             sort: this.getSort(),
             parentRecordId: this.getParentRecordId(),
-            source
+            source,
+            keepSelection
         };
 
         if (quickFilter) {
@@ -471,7 +525,16 @@ export default class DataUnit {
                                     Promise.all(dispatchPromisses).then(() => resolve());
                                 }).catch(cause => {
                                     const {errorCode} = cause;
+                                    this.dispatchAction(Action.SAVING_ERROR);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                                    if(cause instanceof ServiceCanceledException){
+                                        console.debug("Service canceled: " + cause.message);
+                                        resolve();
+                                    } 
+                                    if(cause instanceof SilentException){
+                                        fail(cause);
+                                        return;
+                                    }
                                     fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
                             } else {
@@ -541,8 +604,8 @@ export default class DataUnit {
             if(selection.isAllRecords()){
                 throw new Error("Exclusão remota não implementada.");
             }
-            const records = selection?.records || [];
-            const recordIds = selection?.recordIds || [];
+            const records = selection?.records as Array<Record> || [];
+            const recordIds = selection?.recordIds as Array<string> || [];
             return this.removeRecords(recordIds, records, buffered, undefined, silent);
         }
         return Promise.resolve([]);
@@ -576,10 +639,11 @@ export default class DataUnit {
                                     const currentRecordsKeys = Array.from(getCurrentRecords(this._stateManager).keys());
                                     const removedIndex: Array<number> = recordIds
                                         .map(id => currentRecordsKeys.indexOf(id))
-                                        .filter(index => index > -1);
+                                        .filter(index => index > -1)
+                                        .sort((a, b) => a - b);
 
                                     const nextIndex = Math.min(removedIndex.slice(-1)[0] + 1, currentRecordsKeys.length);
-                                    const selectionAfterRemove = [currentRecordsKeys[nextIndex]];
+                                    const selectionAfterRemove = currentRecordsKeys[nextIndex] ? [currentRecordsKeys[nextIndex]] : [];
 
                                     this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false, selectionAfterRemove }, executionCtx);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
@@ -643,7 +707,6 @@ export default class DataUnit {
      * 
     */
     public getFormattedValue(fieldName: string, value?: any): string {
-        
         const descriptor = this.getField(fieldName);
         if (value == undefined) {
             value = this.getFieldValue(fieldName);
@@ -666,7 +729,7 @@ export default class DataUnit {
      * 
     */
     public addInterceptor(interceptor: DUActionInterceptor): void {
-        this._interceptors.push(interceptor);
+        this._interceptors.set(interceptor.interceptAction.toString(), interceptor);
     }
 
     /**
@@ -677,7 +740,7 @@ export default class DataUnit {
      * 
     */
     public removeInterceptor(interceptor: DUActionInterceptor) {
-        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+        this._interceptors.delete(interceptor.interceptAction.toString())
     }
 
     /**
@@ -722,6 +785,7 @@ export default class DataUnit {
         return this.dispatchAction(Action.PAGINATION_UPDATED, info, undefined);
     }
 
+
     /**
      * 
      * Define a lógica de ordenação dos registros.
@@ -786,7 +850,8 @@ export default class DataUnit {
      * 
      */
     public set records(records: Array<Record>) {
-        this.dispatchAction(Action.DATA_LOADED, { records }, undefined);
+        const paginationInfo = this.getPaginationInfo();
+        this.dispatchAction(Action.DATA_LOADED, { records, paginationInfo }, undefined);
     }
 
     /**
@@ -879,8 +944,12 @@ export default class DataUnit {
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectionInfo = this.getSelectionInfo();
         if (selectionInfo) {
-            const selectedRecords = selectionInfo.records;
+            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);
             }
         }
@@ -946,21 +1015,31 @@ export default class DataUnit {
      * @param fieldName -Identificador do campo a ser modificado.
      * @param newValue - Valor a ser inserido no campo.
      * @param records - Indica quais registros foram afetados pela alteração no valor do campo.
+     * @param options - Configurações do evento
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
-     * 
-    */
-    public async setFieldValue(fieldName: string, newValue: any, records?: Array<string>): 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) await this.addRecord();
 
-        if(!this.hasNewRecord() && !this.getSelectedRecord())  await this.addRecord();
-        
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
-        
+
+        if(!(newValue instanceof Promise) && ObjectUtils.hasEquivalentProps(currentValue, typedValue)){
+            return Promise.resolve(false);
+        }
+
         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));
+                    accept(this.setFieldValue(fieldName, resolvedValue, records,  options));
                 });
             });
             this._savingLockers.push(promise);
@@ -968,7 +1047,7 @@ export default class DataUnit {
         }
 
         if (currentValue !== typedValue) {
-            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+            const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined, options);
             this._savingLockers.push(promise);
             return promise;
         }
@@ -989,6 +1068,18 @@ export default class DataUnit {
         this.dispatchAction(Action.FIELD_INVALIDATED, { fieldName, message, recordId }, undefined);
     }
 
+    /**
+     * 
+     *  Cancela o saving exibindo os campos invalidos.
+     * 
+     * @param filds - Lista dos campos
+     * @param recordId - Indica qual registro está com os campos inválido.
+     * 
+    */
+    public savingCanceled(fields: Array<{name: string, message: string}>, recordId: string): void {
+        this.dispatchAction(Action.SAVING_CANCELED, { fields, recordId }, undefined);
+    }
+
     /**
      * 
      *  Limpa campos inválidos.
@@ -1096,7 +1187,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(getSelectionInfo(this._stateManager)));
+                .then(()=>resolve(this.getSelectionInfo()));
         });
     }
 
@@ -1117,35 +1208,53 @@ export default class DataUnit {
      * 
      * @param selection - IDs dos registros selecionados no snapshot atual
      * @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());
-        }
+        if(!selection) return Promise.resolve(this.getSelectionInfo());
 
         return new Promise(resolve => {
-            const newSelection: Set<string> = new Set(getSelection(this._stateManager));
-            const currentRecords = getCurrentRecords(this._stateManager) || new Map();
-            Array.from(currentRecords.keys()).forEach(
-                recordId => {
-                    if(selection.includes(recordId)){
-                        newSelection.add(recordId);
-                    } else {
-                        newSelection.delete(recordId);
-                    }
-                }
-            );
+            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>{
+        return new Promise(resolve => {
+            const newSelection: Set<string> = new Set<string>();
+
+            const cachedSelection = getSelection(this._stateManager);
+            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));
+
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) })
+              .then(()=> resolve(this.getSelectionInfo()));
         });
     }
 
+    /**
+     * Seleciona todos os registros da página.
+     *
+     * @returns - Informações sobre a seleção.
+     */
+     public selectAllRecords(): Promise<SelectionInfo|undefined>{
+         return this.updatePageSelectionAll(true);
+    }
+
+    /**
+     * Desseleciona todos os registros da página.
+     *
+     * @returns - Informações sobre a seleção.
+     */
+     public unSelectAllRecords(): Promise<SelectionInfo|undefined>{
+        return this.updatePageSelectionAll(false);
+     }
+
     /**
      * 
      * Obtém informações sobre a seleção atual.
@@ -1153,8 +1262,26 @@ export default class DataUnit {
      * @returns - Objeto com informações como registros selecionados e seleção por critério.
      * 
      **/ 
-    public getSelectionInfo(): SelectionInfo | undefined {
-        return getSelectionInfo(this._stateManager)
+    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);
+            }
+
+            return records;
+        }
+
+        if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+            const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
+            selectionInfo.records?.sort(sortingFunction)
+        }
+
+        return selectionInfo;
     }
 
     /**
@@ -1168,6 +1295,15 @@ export default class DataUnit {
        return getSelectedRecord(this._stateManager);
     }
 
+    /**
+     * Retorna o DataUnit pai
+     *
+     * @returns DataUnit pai ou undefined
+     */
+    public getParentDataUnit(): DataUnit | undefined {
+        return this._parentDataUnit;
+    }
+
     /**
      * 
      * Limpa todos os registros do DataUnit
@@ -1255,14 +1391,28 @@ export default class DataUnit {
     /**
      * 
      * Retorna se existe algum tipo de alteração pendente.
-     * 
+     *
+     * @param ignoreChildren: Define se deverá ignorar alterações pendentes no DataUnit filho.
      * @returns Verdadeiro se existir alterações pendentes.
      * 
     */ 
-    public isDirty(): boolean {
+    public isDirty(ignoreChildren?: boolean): boolean {
+        if(ignoreChildren) return isDirty(this._stateManager);
+
         return isDirty(this._stateManager) || this.childrenIsDirty();
     }
 
+    /**
+     *
+     * Retorna se existe alterações pendentes no DataUnit pai.
+     *
+     * @returns Verdadeiro se existir alterações pendentes e Falso caso não exista alterações ou não exista DataUnit pai.
+     *
+     */
+    public isParentDirty(): boolean {
+        return this._parentDataUnit ? this._parentDataUnit.isDirty(true) : false;
+    }
+
     /**
      * 
      * Retorna se existe algum DataUnit detail com alterações pendentes.
@@ -1435,17 +1585,17 @@ export default class DataUnit {
      * @returns - Verdadeiro se ação iniciada.
      * 
     */
-    private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): 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) {
                 action = executionCtx.before(action);
             }
-            if (action && this._interceptors && this._interceptors.length > 0) {
+            if (action && this._interceptors && this._interceptors.size > 0) {
                 action = await this.intercept(action, this._interceptors.values());
             }
             if (action) {
-                this.doDispatchAction(action);
+                this.doDispatchAction(action, options);
                 if (executionCtx && executionCtx.after) {
                     executionCtx.after(action)
                 }
@@ -1483,16 +1633,13 @@ export default class DataUnit {
      * @param action - Ações em execução no DataUnit.
      * 
     */
-    private doDispatchAction(action: DataUnitAction): 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 => {
-            /* 
-            if some observer throws exceptions,
-            should be continued
-            */
+            //if some observer throws exceptions, should be continued
             try {
-                f(action);
+                f(action, options);
             } catch (e) {
                 console.warn("[DataUnit] error while call observer", e);
             }
@@ -1529,10 +1676,17 @@ export default class DataUnit {
      * Ela vai ser chamada sempre que uma ação for despachada (dispatchAction()).
      * 
      * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
-     * 
+     * @param uuid - Identificador do observer. Quando não informado, será gerado um identificador aleatório.
     */
-    public subscribe(observer: (action: DataUnitAction) => void) {
-        this._observers.push(observer);
+    public subscribe(observer: (action: DataUnitAction, options?: DataUnitEventOptions) => void | Promise<void>, uuid?: string): string {
+        if (uuid) {
+            this._observers.set(uuid, observer);
+        } else {
+            uuid = StringUtils.generateUUID();
+            this._observers.set(uuid, observer);
+        }
+
+        return uuid;
     }
 
     /**
@@ -1540,10 +1694,18 @@ export default class DataUnit {
      * Remove um observer existente.
      * 
      * @param observer - Observer que se deseja remover.
-     * 
+     * @param uuid - Identificador do observer. Quando não informado o delete removera com base no equals do observer.
     */
-    public unsubscribe(observer: Function) {
-        this._observers = this._observers.filter(f => f !== observer);
+    public unsubscribe(observer: Function, uuid?: string) {
+        if (uuid) {
+            this._observers.delete(uuid);
+        } else {
+            this._observers.forEach((valor, chave) => {
+                if (valor == observer) {
+                    this._observers.delete(chave);
+                }
+            });
+        }
     }
 
     /**
@@ -1556,18 +1718,21 @@ export default class DataUnit {
     public reloadCurrentRecord(): Promise<Array<Record>>{        
         return new Promise(async (resolve, fail) => {
             const selection = getSelection(this._stateManager);
-            this.dispatchAction(Action.LOADING_RECORD, selection);
+            await this.dispatchAction(Action.LOADING_RECORD, selection);
             
             if(!this.recordLoader || !this.dataLoader) {
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                resolve([]);
                 return;
             }
             
-            this.recordLoader(this, selection).then(response => {
-                this.dispatchAction(Action.RECORD_LOADED, response)
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
-            }).catch(cause => {
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+            this.recordLoader(this, selection).then(async response => {
+                await this.dispatchAction(Action.RECORD_LOADED, response)
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+
+                resolve(response);
+            }).catch(async cause => {
+                await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 const {errorCode} = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
             });
@@ -1662,11 +1827,12 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar invisível.
      * 
     */
-    public hideField(fieldName:string) {
+    public hideField(fieldName:string, options:HideFieldOptions) {
         const fieldDescriptor = this.getField(fieldName);
 
         if(fieldDescriptor?.visible === true){
             fieldDescriptor.visible = false;
+            fieldDescriptor.properties = {...fieldDescriptor.properties, visibleOnConfig: options.visibleOnConfig };
             this.metadata = {...this.metadata};
         }
     }
@@ -1706,7 +1872,7 @@ export default class DataUnit {
         }
 
         if (selection) {
-            return selection.records;
+            return selection.records as Array<Record>;
         }
     }
 
@@ -1724,12 +1890,15 @@ 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){
+            return [];
+        }
 
-        if(selection != undefined && 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`.");
         }
 
-        return selection?.recordIds || [];
+        return selection?.recordIds as Array<string>;
     }
 
     /**
@@ -1765,6 +1934,10 @@ export default class DataUnit {
         return loadingLockerResolver || Promise.resolve;
     }
 
+    public set allowReleaseCallbacks(allow: boolean){
+        this._allowReleaseCallbacks = allow;
+    }
+
     private async processLoadingLockers(){
         if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);
@@ -1774,6 +1947,15 @@ export default class DataUnit {
 
 }
 
+export interface LoadDataParams {
+    quickFilter?: QuickFilter;
+    executionCtx?: ExecutionContext;
+    checkLastFilter?: boolean;
+    source?: string;
+    selectFirstRecord?: boolean;
+    keepSelection?: boolean
+}
+
 export interface DUActionInterceptor {
     interceptAction(action: DataUnitAction): DataUnitAction | Promise<DataUnitAction>;
 }
@@ -1906,12 +2088,13 @@ export enum SelectionMode{
 
 export class SelectionInfo{
 
-    private _records: Array<Record>;
     public mode: SelectionMode;
-    private _total?: number;
     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;
@@ -1922,7 +2105,10 @@ export class SelectionInfo{
 
     public get records(): Array<Record> | undefined{
         if(this.isAllRecords()){
-            throw new Error("Erro interno: [ALL_RECORDS] - Impossível retornar os registros selecionados numa seleção virtual.")
+            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;
     }
@@ -1941,7 +2127,7 @@ export class SelectionInfo{
         if(this.isAllRecords()){
             return this._total || 0;
         }
-        return this.records == undefined ? 0: this.records.length;
+        return this.records == undefined ? 0 : (this.records as Array<Record>).length;
     }
 
     public isAllRecords(): boolean{
@@ -1952,3 +2138,9 @@ export class SelectionInfo{
         return this.length === 0;
     }
 }
+
+export type DataUnitEventOptions = {[key:string]: any};
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};