@sankhyalabs/core 5.20.0-dev.6 → 5.20.0-dev.60

package/src/dataunit/DataUnit.ts

@@ -26,34 +26,41 @@ 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.
 */
 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;
     
     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 +82,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 +118,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 +152,21 @@ 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;
+    }
+
     /**
      * 
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -180,6 +205,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__)){
@@ -238,13 +265,14 @@ export default class DataUnit {
             if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
                 if (this.dataLoader) {
                     this.dataLoader(this, request).then(
-                        response => {
-                            this.dispatchAction(
+                        async response => {
+                            await this.dispatchAction(
                                 Action.DATA_LOADED, 
-                                {...response, keepSelection: request.keepSelection, filters: request.filters},
+                                {...response, keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord},
                                 executionCtx
                             );
-                            this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+
+                            await this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
 
                             if(selectFirstRecord){
                                 this.requestSelectFirst(executionCtx);
@@ -316,13 +344,16 @@ export default class DataUnit {
         
         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);
@@ -335,11 +366,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);
 
@@ -470,7 +504,15 @@ 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();
+                                    }
                                     fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
                             } else {
@@ -540,8 +582,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([]);
@@ -575,10 +617,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);
@@ -642,7 +685,6 @@ export default class DataUnit {
      * 
     */
     public getFormattedValue(fieldName: string, value?: any): string {
-        
         const descriptor = this.getField(fieldName);
         if (value == undefined) {
             value = this.getFieldValue(fieldName);
@@ -665,7 +707,7 @@ export default class DataUnit {
      * 
     */
     public addInterceptor(interceptor: DUActionInterceptor): void {
-        this._interceptors.push(interceptor);
+        this._interceptors.set(interceptor.interceptAction.toString(), interceptor);
     }
 
     /**
@@ -676,7 +718,7 @@ export default class DataUnit {
      * 
     */
     public removeInterceptor(interceptor: DUActionInterceptor) {
-        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+        this._interceptors.delete(interceptor.interceptAction.toString())
     }
 
     /**
@@ -785,7 +827,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);
     }
 
     /**
@@ -878,8 +921,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);
             }
         }
@@ -945,21 +992,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);
@@ -967,7 +1024,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;
         }
@@ -988,6 +1045,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.
@@ -1095,7 +1164,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()));
         });
     }
 
@@ -1152,8 +1221,16 @@ 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 = () => this.allRecordsLoader?.(this);
+
+        if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+            const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
+            selectionInfo.records?.sort(sortingFunction)
+        }
+
+        return selectionInfo;
     }
 
     /**
@@ -1167,6 +1244,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
@@ -1254,14 +1340,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.
@@ -1434,17 +1534,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)
                 }
@@ -1482,16 +1582,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);
             }
@@ -1528,10 +1625,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;
     }
 
     /**
@@ -1539,10 +1643,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);
+                }
+            });
+        }
     }
 
     /**
@@ -1661,11 +1773,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};
         }
     }
@@ -1705,7 +1818,7 @@ export default class DataUnit {
         }
 
         if (selection) {
-            return selection.records;
+            return selection.records as Array<Record>;
         }
     }
 
@@ -1723,12 +1836,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>;
     }
 
     /**
@@ -1764,6 +1880,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);
@@ -1905,12 +2025,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;
@@ -1921,7 +2042,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;
     }
@@ -1940,7 +2064,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{
@@ -1951,3 +2075,9 @@ export class SelectionInfo{
         return this.length === 0;
     }
 }
+
+export type DataUnitEventOptions = {[key:string]: any};
+
+export type HideFieldOptions = {
+    visibleOnConfig: boolean
+};

package/src/dataunit/DataUnitHelper.ts

@@ -31,17 +31,18 @@ export function defaultDataLoader(dataUnit: DataUnit, request: LoadDataRequest,
 }
 
 function buildPaginationInfo({ offset, limit }: LoadDataRequest, records: Array<Record>): PaginationInfo | undefined {
-  if (offset === undefined || limit === undefined) {
+  if (offset === undefined || limit === undefined || records === undefined) {
     return undefined;
   }
 
-  const lastRecord = Math.min(offset + limit, records.length);
+  const total = records?.length || 0;
+  const lastRecord = Math.min(offset + limit, total);
   return {
-    currentPage: Math.ceil(offset / limit),
+    currentPage: limit === 0 ? 0 : Math.ceil(offset / limit),
     firstRecord: offset,
     lastRecord: lastRecord,
-    total: records.length,
-    hasMore: !!(records.length - lastRecord),
+    total: total,
+    hasMore: !!(total - lastRecord),
   };
 }
 

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -10,10 +10,13 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
-        if(Object.hasOwn(value, "value")){
+        if(value && Object.hasOwn(value, "value")){
             return getSearchFormat(value, descriptor);
         }
-        return value == undefined ? "" : value.toString();
+
+        if(value === null || value === undefined) return  "";
+
+        return value.toString();
     }
 
     if(descriptor?.userInterface === UserInterface.OPTIONSELECTOR){
@@ -43,7 +46,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     const mask = getMask(value, descriptor);
     if(mask != undefined){
         try{
-            return new MaskFormatter(mask).format(value);
+            return new MaskFormatter(mask).format(value, true);
         } catch(error){
             console.warn(`Erro ao formatar valor: ${value}. Mascara: ${mask}. Erro: ${error}`);
         }
@@ -53,6 +56,7 @@ export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
 }
 
 const getNumberFormat = (value: any, descriptor: FieldDescriptor) => {
+    if(value === undefined || value === null) return "";
     if(descriptor.userInterface === UserInterface.INTEGERNUMBER){
         return value;
     }
@@ -84,7 +88,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         }
     }
 
-    if(typeof value === "object"){
+    if(value && typeof value === "object" ){
         value = value.value
     }
 
@@ -92,7 +96,7 @@ const getOptionFormat = (value: any, descriptor: FieldDescriptor) => {
         return options[value];
     }
 
-    return value;     
+    return value ?? "";
 }
 
 
@@ -103,7 +107,7 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     }
 
     const mask = descriptor.properties?.mask;
-    if(mask == undefined){
+    if(mask == undefined || !value){
         return;
     }
 

package/src/dataunit/loading/LoadDataRequest.ts

@@ -4,7 +4,7 @@ import { Filter, Sort } from "../metadata/UnitMetadata.js";
 /** Atributos enviados na requisição de carregamento dos registros */
 export interface LoadDataRequest {
     /** De onde partiu o refresh. Por padrão a fonte não é identificada */
-    source?: String;
+    source?: string;
 
     /** Indice inicial dos registros que será retornado */
     offset?: number;

package/src/dataunit/loading/PaginationInfo.ts

@@ -18,4 +18,9 @@ export interface PaginationInfo {
 
     /** Se ainda existem mais registros */
     hasMore: boolean;
+    
+    /** Informa se o carregamento de dados em background está sendo executado
+     *  Caso o dataunit não tenha carga paralela o valor será indefinido
+     */
+    loadingInProgress?: boolean;
 }

package/src/dataunit/metadata/DataType.ts

@@ -119,6 +119,9 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
         } else if (dataType === DataType.DATE) {
             if (typeof value === "string") {
                 value = DateUtils.strToDate(value);
+                if (value == undefined) {
+                    return value;
+                }
             }
             return DateUtils.formatRfc3339(value as Date);
         } else {