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

package/dist/dataunit/DataUnit.js

@@ -29,6 +29,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.
 */
@@ -37,6 +40,8 @@ export default class DataUnit {
         var _a;
         this._childByName = new Map();
         this._savingLockers = [];
+        this._waitingToReload = false;
+        this._cancelPagination = false;
         /**
          *
          * Trata as Actions do DataUnit Parent
@@ -50,6 +55,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__)) {
@@ -75,11 +82,12 @@ export default class DataUnit {
             InvalidFieldsReducer,
             SnapshotReducer
         ]);
-        this._observers = [];
+        this._observers = new Map();
         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 = [];
@@ -107,10 +115,12 @@ export default class DataUnit {
      * - Sorting Providers
      */
     releaseCallbacks() {
-        this._observers = [];
+        if (!this._allowReleaseCallbacks)
+            return;
+        this._observers = new Map();
         this._filterProviders = new Map();
         this._sortingProvider = undefined;
-        this._interceptors = [];
+        this._interceptors = new Map();
     }
     /**
      * Adiciona uma propriedade transacional que será envida aos
@@ -135,6 +145,31 @@ export default class DataUnit {
     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;
+    }
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    get cancelPagination() {
+        return this._cancelPagination;
+    }
+    /**
+     * Informa se a paginação deve ser cancelada.
+     */
+    set cancelPagination(cancelPagination) {
+        this._cancelPagination = cancelPagination;
+    }
     /**
      *
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -203,7 +238,7 @@ export default class DataUnit {
             if (yield this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
                 if (this.dataLoader) {
                     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 }), executionCtx);
+                        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);
@@ -255,6 +290,11 @@ export default class DataUnit {
             }
         });
     }
+    loadDataWithParams({ source, keepSelection, selectFirstRecord, executionCtx, checkLastFilter, quickFilter }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord, keepSelection);
+        });
+    }
     /**
      *
      * Carrega os registros do DataUnit.
@@ -266,18 +306,21 @@ export default class DataUnit {
      * @returns - Registros requisitados.
      *
     */
-    loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord) {
+    loadData(quickFilter, executionCtx, checkLastFilter, source, selectFirstRecord, keepSelection) {
         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);
+            const loadDataRequest = this.getLoadDataRequest(quickFilter, source, keepSelection);
             return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter, selectFirstRecord);
         });
     }
@@ -293,6 +336,9 @@ export default class DataUnit {
     */
     gotoPage(page, executionCtx) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this._pageSize === 0) {
+                return;
+            }
             let request = getCurrentRequest(this._stateManager);
             if (!request) {
                 request = {
@@ -333,12 +379,13 @@ export default class DataUnit {
             return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
         });
     }
-    getLoadDataRequest(quickFilter, source) {
+    getLoadDataRequest(quickFilter, source, keepSelection) {
         const request = {
             filters: (quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.filter) ? [quickFilter.filter] : this.getFilters(),
             sort: this.getSort(),
             parentRecordId: this.getParentRecordId(),
-            source
+            source,
+            keepSelection
         };
         if (quickFilter) {
             request.quickFilter = quickFilter;
@@ -405,7 +452,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));
                                     });
                                 }
@@ -509,9 +565,10 @@ 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);
@@ -591,7 +648,7 @@ export default class DataUnit {
      *
     */
     addInterceptor(interceptor) {
-        this._interceptors.push(interceptor);
+        this._interceptors.set(interceptor.interceptAction.toString(), interceptor);
     }
     /**
      *
@@ -601,7 +658,7 @@ export default class DataUnit {
      *
     */
     removeInterceptor(interceptor) {
-        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+        this._interceptors.delete(interceptor.interceptAction.toString());
     }
     /**
      *
@@ -700,7 +757,8 @@ export default class DataUnit {
      *
      */
     set records(records) {
-        this.dispatchAction(Action.DATA_LOADED, { records }, undefined);
+        const paginationInfo = this.getPaginationInfo();
+        this.dispatchAction(Action.DATA_LOADED, { records, paginationInfo }, undefined);
     }
     /**
      *
@@ -787,6 +845,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);
@@ -845,27 +906,35 @@ 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.
      *
-    */
-    setFieldValue(fieldName, newValue, records) {
+     */
+    setFieldValue(fieldName, newValue, records, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasNewRecord() && !this.getSelectedRecord())
+            const noRecordSelected = !this.hasNewRecord() && !this.getSelectedRecord();
+            const suppressCreateNewRecord = options === null || options === void 0 ? void 0 : options.suppressCreateNewRecord;
+            if (noRecordSelected && suppressCreateNewRecord)
+                return Promise.resolve(false);
+            if (noRecordSelected)
                 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 => {
                         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);
                 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;
             }
@@ -884,6 +953,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.
@@ -982,7 +1062,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()));
         });
     }
     /**
@@ -1001,30 +1081,44 @@ 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.
     */
     updatePageSelection(selection, executionCtx) {
-        if (!selection) {
+        if (!selection)
             return Promise.resolve(this.getSelectionInfo());
-        }
         return new Promise(resolve => {
-            const newSelection = 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 = new Set(selection);
             this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
-                .then(() => {
-                resolve(this.getSelectionInfo());
-            });
+                .then(() => resolve(this.getSelectionInfo()));
+        });
+    }
+    updatePageSelectionAll(addRecords) {
+        return new Promise(resolve => {
+            const newSelection = new Set();
+            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.
+     */
+    selectAllRecords() {
+        return this.updatePageSelectionAll(true);
+    }
+    /**
+     * Desseleciona todos os registros da página.
+     *
+     * @returns - Informações sobre a seleção.
+     */
+    unSelectAllRecords() {
+        return this.updatePageSelectionAll(false);
+    }
     /**
      *
      * Obtém informações sobre a seleção atual.
@@ -1033,7 +1127,22 @@ export default class DataUnit {
      *
      **/
     getSelectionInfo() {
-        return getSelectionInfo(this._stateManager);
+        var _a;
+        const selectionInfo = getSelectionInfo(this._stateManager);
+        selectionInfo.getAllRecords = () => {
+            var _a, _b;
+            let records = (_b = (_a = this.allRecordsLoader) === null || _a === void 0 ? void 0 : _a.call(this, this)) !== null && _b !== void 0 ? _b : [];
+            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);
+            (_a = selectionInfo.records) === null || _a === void 0 ? void 0 : _a.sort(sortingFunction);
+        }
+        return selectionInfo;
     }
     /**
      *
@@ -1045,6 +1154,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
@@ -1132,12 +1249,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.
@@ -1299,18 +1429,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);
                     }
@@ -1350,17 +1480,14 @@ 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 });
         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);
@@ -1395,20 +1522,36 @@ 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.
     */
-    subscribe(observer) {
-        this._observers.push(observer);
+    subscribe(observer, uuid) {
+        if (uuid) {
+            this._observers.set(uuid, observer);
+        }
+        else {
+            uuid = StringUtils.generateUUID();
+            this._observers.set(uuid, observer);
+        }
+        return uuid;
     }
     /**
      *
      * 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.
     */
-    unsubscribe(observer) {
-        this._observers = this._observers.filter(f => f !== observer);
+    unsubscribe(observer, uuid) {
+        if (uuid) {
+            this._observers.delete(uuid);
+        }
+        else {
+            this._observers.forEach((valor, chave) => {
+                if (valor == observer) {
+                    this._observers.delete(chave);
+                }
+            });
+        }
     }
     /**
      *
@@ -1420,19 +1563,21 @@ export default class DataUnit {
     reloadCurrentRecord() {
         return new Promise((resolve, fail) => __awaiter(this, void 0, void 0, function* () {
             const selection = getSelection(this._stateManager);
-            this.dispatchAction(Action.LOADING_RECORD, selection);
+            yield this.dispatchAction(Action.LOADING_RECORD, selection);
             if (!this.recordLoader || !this.dataLoader) {
-                this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                yield 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((response) => __awaiter(this, void 0, void 0, function* () {
+                yield this.dispatchAction(Action.RECORD_LOADED, response);
+                yield this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
+                resolve(response);
+            })).catch((cause) => __awaiter(this, void 0, void 0, function* () {
+                yield this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                 const { errorCode } = cause;
                 fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
-            });
+            }));
         }));
     }
     /**
@@ -1515,10 +1660,11 @@ export default class DataUnit {
      * @param fieldName - nome do campo para ficar invisível.
      *
     */
-    hideField(fieldName) {
+    hideField(fieldName, options) {
         const fieldDescriptor = this.getField(fieldName);
         if ((fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.visible) === true) {
             fieldDescriptor.visible = false;
+            fieldDescriptor.properties = Object.assign(Object.assign({}, fieldDescriptor.properties), { visibleOnConfig: options.visibleOnConfig });
             this.metadata = Object.assign({}, this.metadata);
         }
     }
@@ -1570,10 +1716,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.
@@ -1603,6 +1752,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) {
@@ -1613,6 +1765,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) {
@@ -1698,7 +1851,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;
     }