@sankhyalabs/core 5.20.0-dev.5 → 5.20.0-dev.50

package/dist/dataunit/DataUnit.d.ts

@@ -8,6 +8,7 @@ import { PaginationInfo } from "./loading/PaginationInfo.js";
 */
 export default class DataUnit {
     static CHANGING_PAGE_LOADING_SOURCE: string;
+    static ALL_RECORDS_SELECTION_SOURCE: string;
     static DEFAULT_DATAUNIT_NAME: string;
     private _uuid;
     private _name;
@@ -22,11 +23,14 @@ export default class DataUnit {
     private _loadingLockers;
     private _savingLockers;
     private _defaultSorting;
+    private _allowReleaseCallbacks;
+    private _waitingToReload;
     metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
     saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
     removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
     recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
+    allRecordsLoader?: (dataUnit: DataUnit) => Array<Record> | undefined;
     constructor(name?: string, parentDataUnit?: DataUnit);
     /**
      * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
@@ -43,7 +47,32 @@ export default class DataUnit {
      * - Sorting Providers
      */
     releaseCallbacks(): void;
+    /**
+     * Adiciona uma propriedade transacional que será envida aos
+     * loaders (dataLoader, saveLoader, removeLoader e recordLoader) na chamada.
+     * Essas propriedades serão limpas ao final da execução de cada método.
+     *
+     * @param name - Nome da propriedade
+     * @param value - Valor da propriedade
+     *
+     */
+    addGlobalLoaderProp(name: string, value: string): void;
+    /**
+     * Retorna as propriedades transacionais adicionados anteriores à chamada.
+     *
+     * @returns - Todas as propriedades desde o final do último loader.
+     */
+    getGlobalLoaderProps(): Map<string, string>;
     get dataUnitId(): string;
+    /**
+     * Retorna se o dataUnit está com recarregamento pendente.
+     */
+    isWaitingToReload(): boolean;
+    /**
+     * Define se o dataUnit tem um recarregamento pendente.
+     * @param isWaiting
+     */
+    setWaitingToReload(isWaiting: boolean): void;
     /**
      *
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -429,7 +458,7 @@ export default class DataUnit {
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
      *
     */
-    setFieldValue(fieldName: string, newValue: any, records?: Array<string>): Promise<boolean>;
+    setFieldValue(fieldName: string, newValue: any, records?: Array<string>, options?: DataUnitEventOptions): Promise<boolean>;
     /**
      *
      *  Marca campos como inválidos.
@@ -440,6 +469,18 @@ export default class DataUnit {
      *
     */
     setInvalidField(fieldName: string, message: string, recordId: string): void;
+    /**
+     *
+     *  Cancela o saving exibindo os campos invalidos.
+     *
+     * @param filds - Lista dos campos
+     * @param recordId - Indica qual registro está com os campos inválido.
+     *
+    */
+    savingCanceled(fields: Array<{
+        name: string;
+        message: string;
+    }>, recordId: string): void;
     /**
      *
      *  Limpa campos inválidos.
@@ -540,7 +581,7 @@ export default class DataUnit {
      * @returns - Objeto com informações como registros selecionados e seleção por critério.
      *
      **/
-    getSelectionInfo(): SelectionInfo | undefined;
+    getSelectionInfo(): SelectionInfo;
     /**
      *
      * Retorna apenas um registro selecionado no Dataunit
@@ -549,6 +590,12 @@ export default class DataUnit {
      *
     */
     getSelectedRecord(): Record | undefined;
+    /**
+     * Retorna o DataUnit pai
+     *
+     * @returns DataUnit pai ou undefined
+     */
+    getParentDataUnit(): DataUnit | undefined;
     /**
      *
      * Limpa todos os registros do DataUnit
@@ -586,10 +633,19 @@ 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.
      *
     */
-    isDirty(): boolean;
+    isDirty(ignoreChildren?: boolean): boolean;
+    /**
+     *
+     * 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.
+     *
+     */
+    isParentDirty(): boolean;
     /**
      *
      * Retorna se existe algum DataUnit detail com alterações pendentes.
@@ -743,7 +799,7 @@ export default class DataUnit {
      * @param observer - Função que recebe como parâmetro as ações que serão monitoradas.
      *
     */
-    subscribe(observer: (action: DataUnitAction) => void): void;
+    subscribe(observer: (action: DataUnitAction, options?: DataUnitEventOptions) => void | Promise<void>): void;
     /**
      *
      * Remove um observer existente.
@@ -861,6 +917,7 @@ export default class DataUnit {
      * @returns Retorna uma função responsável por liberar o lock adicionado.
      */
     addLoadingLocker(): Function;
+    set allowReleaseCallbacks(allow: boolean);
     private processLoadingLockers;
 }
 export interface DUActionInterceptor {
@@ -960,11 +1017,12 @@ export declare enum SelectionMode {
     SOME_RECORDS = "SOME_RECORDS"
 }
 export declare class SelectionInfo {
-    private _records;
     mode: SelectionMode;
-    private _total?;
     filters?: Array<Filter>;
     sort?: Array<Sort>;
+    getAllRecords?: () => Array<Record> | undefined;
+    private _records;
+    private _total?;
     constructor(records: Array<Record>, mode?: SelectionMode, total?: number, filters?: Array<Filter>, sort?: Array<Sort>);
     get records(): Array<Record> | undefined;
     get recordIds(): Array<string> | undefined;
@@ -972,3 +1030,6 @@ export declare class SelectionInfo {
     isAllRecords(): boolean;
     isEmpty(): boolean;
 }
+export type DataUnitEventOptions = {
+    [key: string]: any;
+};

package/dist/dataunit/DataUnit.js

@@ -28,6 +28,9 @@ import { getFormattedValue } from "./formatting/PrettyFormatter.js";
 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";
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
 */
@@ -36,6 +39,7 @@ export default class DataUnit {
         var _a;
         this._childByName = new Map();
         this._savingLockers = [];
+        this._waitingToReload = false;
         /**
          *
          * Trata as Actions do DataUnit Parent
@@ -49,6 +53,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 = (_a = this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.getSelectedRecord();
                     if (selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)) {
@@ -62,6 +68,7 @@ export default class DataUnit {
         this._pageSize = 0;
         this._stateManager = new StateManager([
             HistReducer,
+            LoadingPropertiesReducer,
             UnitMetadataReducer,
             LoadingControlReducer,
             RecordsReducer,
@@ -77,7 +84,8 @@ export default class DataUnit {
         this._filterProviders = new Map();
         this._sortingProvider = undefined;
         this._defaultSorting = [];
-        this._interceptors = [];
+        this._allowReleaseCallbacks = true;
+        this._interceptors = new Map();
         this._parentDataUnit = parentDataUnit;
         (_a = this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.subscribe(this.onDataUnitParentEvent);
         this._loadingLockers = [];
@@ -105,14 +113,49 @@ export default class DataUnit {
      * - Sorting Providers
      */
     releaseCallbacks() {
+        if (!this._allowReleaseCallbacks)
+            return;
         this._observers = [];
         this._filterProviders = new Map();
         this._sortingProvider = undefined;
-        this._interceptors = [];
+        this._interceptors = new Map();
+    }
+    /**
+     * Adiciona uma propriedade transacional que será envida aos
+     * loaders (dataLoader, saveLoader, removeLoader e recordLoader) na chamada.
+     * Essas propriedades serão limpas ao final da execução de cada método.
+     *
+     * @param name - Nome da propriedade
+     * @param value - Valor da propriedade
+     *
+     */
+    addGlobalLoaderProp(name, value) {
+        this.dispatchAction(Action.LOADING_PROPERTY_ADDED, { [name]: value });
+    }
+    /**
+     * Retorna as propriedades transacionais adicionados anteriores à chamada.
+     *
+     * @returns - Todas as propriedades desde o final do último loader.
+     */
+    getGlobalLoaderProps() {
+        return getLoadingProperties(this._stateManager) || new Map();
     }
     get dataUnitId() {
         return this._uuid;
     }
+    /**
+     * Retorna se o dataUnit está com recarregamento pendente.
+     */
+    isWaitingToReload() {
+        return this._waitingToReload;
+    }
+    /**
+     * Define se o dataUnit tem um recarregamento pendente.
+     * @param isWaiting
+     */
+    setWaitingToReload(isWaiting) {
+        this._waitingToReload = isWaiting;
+    }
     /**
      *
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -180,15 +223,17 @@ export default class DataUnit {
         return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
             if (yield this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
                 if (this.dataLoader) {
-                    this.dataLoader(this, request).then(response => {
-                        this.dispatchAction(Action.DATA_LOADED, Object.assign(Object.assign({}, response), { keepSelection: request.keepSelection, filters: request.filters }), executionCtx);
+                    this.dataLoader(this, request).then((response) => __awaiter(this, void 0, void 0, function* () {
+                        yield this.dispatchAction(Action.DATA_LOADED, Object.assign(Object.assign({}, response), { keepSelection: request.keepSelection, filters: request.filters, selectFirstRecord }), executionCtx);
+                        yield this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                         if (selectFirstRecord) {
                             this.requestSelectFirst(executionCtx);
                         }
                         resolve(response);
-                    }).catch(error => {
+                    })).catch(error => {
                         console.error(error);
                         const { errorCode } = error;
+                        this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                         fail(new ErrorException("Erro ao carregar registros", error, errorCode));
                     });
                 }
@@ -245,13 +290,16 @@ export default class DataUnit {
     loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.processLoadingLockers();
-            if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
-                if (this.records) {
-                    this.clearDataUnit();
+            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: []
+                    });
                 }
-                return Promise.resolve({
-                    records: []
-                });
             }
             const loadDataRequest = this.getLoadDataRequest(quickFilter, source);
             return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter, selectFirstRecord);
@@ -368,6 +416,7 @@ export default class DataUnit {
                                 if (this.saveLoader) {
                                     const changes = this.getAllChangesToSave();
                                     this.saveLoader(this, changes).then((records) => {
+                                        this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                         const recordsByDataUnit = this.getRecordsByDataUnit(records);
                                         const dispatchPromisses = [];
                                         for (const [ownerDataUnitName, splittedRecords] of recordsByDataUnit) {
@@ -380,10 +429,19 @@ export default class DataUnit {
                                         Promise.all(dispatchPromisses).then(() => resolve());
                                     }).catch(cause => {
                                         const { errorCode } = cause;
-                                        fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
+                                        this.dispatchAction(Action.SAVING_ERROR);
+                                        this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                                        if (cause instanceof ServiceCanceledException) {
+                                            console.debug("Service canceled: " + cause.message);
+                                            resolve();
+                                        }
+                                        else {
+                                            fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
+                                        }
                                     });
                                 }
                                 else {
+                                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     resolve();
                                 }
                             });
@@ -471,6 +529,7 @@ export default class DataUnit {
         return __awaiter(this, void 0, void 0, function* () {
             if (recordIds) {
                 if (buffered || !this.removeLoader) {
+                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                     this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
                 }
                 else {
@@ -481,12 +540,15 @@ export default class DataUnit {
                                     const currentRecordsKeys = Array.from(getCurrentRecords(this._stateManager).keys());
                                     const removedIndex = 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);
                                     resolve(removedIds);
                                 }).catch(error => {
+                                    this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     const { errorCode } = error;
                                     fail(new ErrorException("Erro ao remover registros", error, errorCode));
                                 });
@@ -561,7 +623,7 @@ export default class DataUnit {
      *
     */
     addInterceptor(interceptor) {
-        this._interceptors.push(interceptor);
+        this._interceptors.set(interceptor.interceptAction.toString(), interceptor);
     }
     /**
      *
@@ -571,7 +633,7 @@ export default class DataUnit {
      *
     */
     removeInterceptor(interceptor) {
-        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+        this._interceptors.delete(interceptor.interceptAction.toString());
     }
     /**
      *
@@ -757,6 +819,9 @@ export default class DataUnit {
     copySelected(executionCtx) {
         const selectionInfo = this.getSelectionInfo();
         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;
             if (selectedRecords) {
                 this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
@@ -818,12 +883,15 @@ export default class DataUnit {
      * @returns - Promise que será resolvida quando o novo valor for persistido no state.
      *
     */
-    setFieldValue(fieldName, newValue, records) {
+    setFieldValue(fieldName, newValue, records, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.hasNewRecord() && !this.getSelectedRecord())
                 yield 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 = new Promise(accept => {
                     newValue.then(resolvedValue => {
@@ -835,7 +903,7 @@ export default class DataUnit {
                 return promise;
             }
             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;
             }
@@ -854,6 +922,17 @@ export default class DataUnit {
     setInvalidField(fieldName, message, recordId) {
         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.
+     *
+    */
+    savingCanceled(fields, recordId) {
+        this.dispatchAction(Action.SAVING_CANCELED, { fields, recordId }, undefined);
+    }
     /**
      *
      *  Limpa campos inválidos.
@@ -952,7 +1031,7 @@ export default class DataUnit {
     setSelection(selection, executionCtx) {
         return new Promise(resolve => {
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
-                .then(() => resolve(getSelectionInfo(this._stateManager)));
+                .then(() => resolve(this.getSelectionInfo()));
         });
     }
     /**
@@ -1003,7 +1082,14 @@ export default class DataUnit {
      *
      **/
     getSelectionInfo() {
-        return getSelectionInfo(this._stateManager);
+        var _a;
+        const selectionInfo = getSelectionInfo(this._stateManager);
+        selectionInfo.getAllRecords = () => { var _a; return (_a = this.allRecordsLoader) === null || _a === void 0 ? void 0 : _a.call(this, this); };
+        if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+            const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort);
+            (_a = selectionInfo.records) === null || _a === void 0 ? void 0 : _a.sort(sortingFunction);
+        }
+        return selectionInfo;
     }
     /**
      *
@@ -1015,6 +1101,14 @@ export default class DataUnit {
     getSelectedRecord() {
         return getSelectedRecord(this._stateManager);
     }
+    /**
+     * Retorna o DataUnit pai
+     *
+     * @returns DataUnit pai ou undefined
+     */
+    getParentDataUnit() {
+        return this._parentDataUnit;
+    }
     /**
      *
      * Limpa todos os registros do DataUnit
@@ -1102,12 +1196,25 @@ 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.
      *
     */
-    isDirty() {
+    isDirty(ignoreChildren) {
+        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.
+     *
+     */
+    isParentDirty() {
+        return this._parentDataUnit ? this._parentDataUnit.isDirty(true) : false;
+    }
     /**
      *
      * Retorna se existe algum DataUnit detail com alterações pendentes.
@@ -1269,18 +1376,18 @@ export default class DataUnit {
      * @returns - Verdadeiro se ação iniciada.
      *
     */
-    dispatchAction(actionType, payload, executionCtx) {
+    dispatchAction(actionType, payload, executionCtx, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                 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 = yield this.intercept(action, this._interceptors.values());
                 }
                 if (action) {
-                    this.doDispatchAction(action);
+                    this.doDispatchAction(action, options);
                     if (executionCtx && executionCtx.after) {
                         executionCtx.after(action);
                     }
@@ -1320,7 +1427,7 @@ export default class DataUnit {
      * @param action - Ações em execução no DataUnit.
      *
     */
-    doDispatchAction(action) {
+    doDispatchAction(action, options = {}) {
         var _a;
         this._stateManager.process(action);
         (_a = this === null || this === void 0 ? void 0 : this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.dispatchAction(Action.CHILD_CHANGED, { srcAction: action, srcDataUnit: this });
@@ -1330,7 +1437,7 @@ export default class DataUnit {
             should be continued
             */
             try {
-                f(action);
+                f(action, options);
             }
             catch (e) {
                 console.warn("[DataUnit] error while call observer", e);
@@ -1391,13 +1498,15 @@ export default class DataUnit {
         return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
             const selection = getSelection(this._stateManager);
             this.dispatchAction(Action.LOADING_RECORD, selection);
-            if (!this.dataLoader)
-                return;
-            if (!this.recordLoader)
+            if (!this.recordLoader || !this.dataLoader) {
+                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 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);
                 const { errorCode } = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
             });
@@ -1538,10 +1647,13 @@ export default class DataUnit {
     getSelection() {
         console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
         const selection = this.getSelectionInfo();
-        if (selection != undefined && selection.isAllRecords()) {
+        if (selection == undefined) {
+            return [];
+        }
+        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 === null || selection === void 0 ? void 0 : selection.recordIds) || [];
+        return selection === null || selection === void 0 ? void 0 : selection.recordIds;
     }
     /**
      * Adiciona um campo stand-alone ao dataUnit.
@@ -1571,6 +1683,9 @@ export default class DataUnit {
         }));
         return loadingLockerResolver || Promise.resolve;
     }
+    set allowReleaseCallbacks(allow) {
+        this._allowReleaseCallbacks = allow;
+    }
     processLoadingLockers() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._loadingLockers.length) {
@@ -1581,6 +1696,7 @@ export default class DataUnit {
     }
 }
 DataUnit.CHANGING_PAGE_LOADING_SOURCE = "CHANGING_PAGE_LOADING_SOURCE";
+DataUnit.ALL_RECORDS_SELECTION_SOURCE = "ALL_RECORDS_SELECTION_SOURCE";
 DataUnit.DEFAULT_DATAUNIT_NAME = "dataunit";
 export var ChangeOperation;
 (function (ChangeOperation) {
@@ -1666,7 +1782,10 @@ export class SelectionInfo {
     }
     get records() {
         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;
     }