@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/dist/dataunit/DataUnit.js

@@ -0,0 +1,1621 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { convertType, DataType, toString } from "./metadata/DataType.js";
+import { Action, DataUnitAction } from "./state/action/DataUnitAction.js";
+import StateManager from "./state/StateManager.js";
+import ErrorException from "../exceptions/ErrorException.js";
+import WaitingChangeException from "../exceptions/WaitingChangeException.js";
+import { StringUtils } from "../utils/StringUtils.js";
+import ObjectUtils from "../utils/ObjectUtils.js";
+import { AddedRecordsReducer, getAddedRecords, prepareAddedRecordId, prepareCopiedRecord } from "./state/slice/AddedRecordsSlice.js";
+import { ChangesReducer, getChangesToSave, isDirty, hasDirtyRecords } from "./state/slice/ChangesSlice.js";
+import { SnapshotReducer, getCurrentRecords, getFieldValue, getModifiedRecords, getSelectionRecords, } from './state/slice/SnapshotSlice.js';
+import { getCurrentPage, getLastPage, getPaginationInfo, getCurrentRequest, LoadingControlReducer, hasMorePages, hasPreviousPages } from "./state/slice/LoadingControlSlice.js";
+import { getRecords, RecordsReducer } from "./state/slice/RecordsSlice.js";
+import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+import { getSelection, getSelectionInfo, hasNext, hasPrevious, SelectionReducer } from "./state/slice/SelectionSlice.js";
+import { getField, getMetadata, UnitMetadataReducer } from "./state/slice/UnitMetadataSlice.js";
+import { getBlockingWaitingChanges, getWaitingChangePromisses, getWaitingChanges, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
+import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
+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";
+const DEFAULT_DATAUNIT_NAME = "dataunit";
+/***
+ * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
+ */
+export default class DataUnit {
+    constructor(name = DEFAULT_DATAUNIT_NAME, parentDataUnit) {
+        var _a;
+        this._childByName = new Map();
+        this._savingLockers = [];
+        /**
+         *
+         * Trata as Actions do DataUnit Parent
+         *
+         *
+        */
+        this.onDataUnitParentEvent = (action) => {
+            var _a;
+            switch (action.type) {
+                case Action.SELECTION_CHANGED:
+                case Action.NEXT_SELECTED:
+                case Action.PREVIOUS_SELECTED:
+                case Action.DATA_LOADED:
+                    this.clearDataUnit();
+                    const selectedRecord = (_a = this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.getSelectedRecord();
+                    if (selectedRecord != undefined && !this.isNewRecord(selectedRecord.__record__id__)) {
+                        this.loadData();
+                    }
+                    break;
+            }
+        };
+        this._uuid = uuid();
+        this._name = `${name}?uuid=${this._uuid}`;
+        this._pageSize = 0;
+        this._stateManager = new StateManager([
+            HistReducer,
+            UnitMetadataReducer,
+            LoadingControlReducer,
+            RecordsReducer,
+            RemovedRecordsReducer,
+            AddedRecordsReducer,
+            SelectionReducer,
+            ChangesReducer,
+            WaitingChangesReducer,
+            InvalidFieldsReducer,
+            SnapshotReducer
+        ]);
+        this._observers = [];
+        this._filterProviders = new Map();
+        this._sortingProvider = undefined;
+        this._interceptors = [];
+        this._parentDataUnit = parentDataUnit;
+        (_a = this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.subscribe(this.onDataUnitParentEvent);
+        this._loadingLockers = [];
+        DataUnitStorage.put(this);
+    }
+    /**
+     * Desfaz vinculos do DataUnit. Chamado quando o DU não é mais necessário.
+     */
+    release() {
+        DataUnitStorage.remove(this._name);
+        if (this._parentDataUnit) {
+            this._parentDataUnit.unsubscribe(this.onDataUnitParentEvent);
+            this._parentDataUnit.removeChildDataunit(this._name);
+        }
+    }
+    get dataUnitId() {
+        return this._uuid;
+    }
+    /**
+     *
+     * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
+     *
+     * @returns - Nome de identificação do DataUnit.
+     *
+    */
+    get name() {
+        return this._name;
+    }
+    /**
+     *
+     * Obtém o valor convertido de acordo com o tipo do campo.
+     *
+     * @param fieldName - Identificador do campo.
+     * @param newValue - Novo valor que será atribuído ao campo pós validação.
+     *
+     * @returns - Novo valor convertido em um tipo valido.
+     *
+    */
+    validateAndTypeValue(fieldName, newValue) {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+    /**
+     *
+     * Obtém chave única para identificação do FilterProvider.
+     *
+     * @param provider - Interface FilterProvider na qual será retornada uma chave correspondente.
+     *
+     * @returns - A chave do provider.
+     *
+    */
+    getFielterProviderKey(provider) {
+        if (provider.getKey) {
+            return provider.getKey();
+        }
+        return StringUtils.hashCode(provider.getFilter.toString());
+    }
+    /**
+     *
+     * Executa o carregamento dos registros.
+     *
+     * @param request - Dados da requisição para carregamento dos registros.
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
+     *
+     * @returns - Registros do DataUnit.
+     *
+    */
+    executeLoadData(request, executionCtx, checkLastFilter) {
+        if (checkLastFilter && this.isSameRequest(request)) {
+            const paginationInfo = getPaginationInfo(this._stateManager);
+            if (paginationInfo) {
+                const response = {
+                    records: getRecords(this._stateManager),
+                    paginationInfo
+                };
+                return Promise.resolve(response);
+            }
+        }
+        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 }), executionCtx);
+                        resolve(response);
+                    }).catch(error => {
+                        const { errorCode } = error;
+                        fail(new ErrorException("Erro ao carregar registros", error, errorCode));
+                    });
+                }
+            }
+        }));
+    }
+    isSameRequest(request) {
+        const lastRequest = getCurrentRequest(this._stateManager);
+        return ObjectUtils.objectToString(request) === ObjectUtils.objectToString(lastRequest || {});
+    }
+    // Loaders
+    /**
+     *
+     * Carrega os metadados do DataUnit.
+     *
+     * @param executionCtx - Contexto de execução do carregamento dos metadados do DataUnit.
+     *
+     * @returns - Metadados carregados.
+     *
+    */
+    loadMetadata(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
+                return new Promise((resolve, fail) => {
+                    if (this.metadataLoader) {
+                        this.metadataLoader(this).then(metadata => {
+                            this.metadata = metadata;
+                            resolve(this.metadata);
+                        }).catch(error => {
+                            const { errorCode } = error;
+                            fail(new ErrorException("Erro ao carregar metadados", error, errorCode));
+                        });
+                    }
+                });
+            }
+        });
+    }
+    /**
+     *
+     * Carrega os registros do DataUnit.
+     *
+     * @param quickFilter - Filtros a serem aplicados.
+     * @param executionCtx - Contexto de execução do carregamento dos registros.
+     * @param checkLastFilter - Habilita a verificação da última requisição, evitando carga desnecessária.
+     *
+     * @returns - Registros requisitados.
+     *
+    */
+    loadData(quickFilter, executionCtx, checkLastFilter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.processLoadingLockers();
+            if (this._parentDataUnit && !this._parentDataUnit.getSelectedRecord()) {
+                if (this.records) {
+                    this.clearDataUnit();
+                }
+                return Promise.resolve({
+                    records: []
+                });
+            }
+            const loadDataRequest = this.getLoadDataRequest(quickFilter);
+            return this.executeLoadData(loadDataRequest, executionCtx, checkLastFilter);
+        });
+    }
+    /**
+     *
+     * Alterna entre os registros por número de página.
+     *
+     * @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.
+     *
+    */
+    gotoPage(page, executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let request = getCurrentRequest(this._stateManager);
+            if (!request) {
+                request = {
+                    filters: this.getFilters(),
+                    sort: this.getSort()
+                };
+            }
+            if (page >= 0 && page <= getLastPage(this._stateManager, this._pageSize)) {
+                return this.executeLoadData(Object.assign(Object.assign({}, request), { limit: this._pageSize, offset: page * this._pageSize, keepSelection: true }), executionCtx);
+            }
+        });
+    }
+    /**
+     *
+     * Vai para os registros da página seguinte.
+     *
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     *
+     * @returns - Registros da página seguinte.
+     *
+    */
+    nextPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) + 1, executionCtx);
+        });
+    }
+    /**
+     *
+     * Vai para os registros da página anterior.
+     *
+     * @param executionCtx - Contexto de execução do carregamento dos registros do DataUnit.
+     *
+     * @returns - Registros da página anterior.
+     *
+    */
+    previousPage(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
+        });
+    }
+    getLoadDataRequest(quickFilter) {
+        const request = {
+            filters: (quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.filter) ? [quickFilter.filter] : this.getFilters(),
+            sort: this.getSort(),
+            parentRecordId: this.getParentRecordId()
+        };
+        if (quickFilter) {
+            request.quickFilter = quickFilter;
+        }
+        if (this._pageSize > 0) {
+            request.limit = this._pageSize;
+            request.offset = 0;
+        }
+        return request;
+    }
+    notifySavingData(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notifyPromises = [];
+            Array.from(this._childByName.values()).forEach(child => notifyPromises.push(child.notifySavingData(executionCtx)));
+            if (isDirty(this._stateManager)) {
+                notifyPromises.push(this.dispatchAction(Action.SAVING_DATA, undefined, executionCtx));
+            }
+            return new Promise(accept => Promise.all(notifyPromises).then(responses => {
+                accept(responses.reduce((previous, current) => previous && current, true));
+            }));
+        });
+    }
+    getBeforeSavePromisses() {
+        let promises = getWaitingChangePromisses(this._stateManager) || [];
+        promises = promises.concat(this._savingLockers);
+        return promises;
+    }
+    /**
+     *
+     * Salva o estado do registro do DataUnit.
+     *
+     * @param executionCtx - Contexto de execução da persistencia do registro do DataUnit.
+     *
+     * @returns - Resposta da solicitação.
+     *
+    */
+    saveData(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
+            if (blockingWaitingChanges && blockingWaitingChanges.size > 0) {
+                const [_, waitingChange] = blockingWaitingChanges.entries().next().value;
+                return Promise.reject(new WaitingChangeException("Aguardando alteração de campo", waitingChange.waitmessage));
+            }
+            else {
+                if (this.isDirty()) {
+                    if (yield this.notifySavingData(executionCtx)) {
+                        const promisses = this.getBeforeSavePromisses();
+                        return new Promise((resolve, fail) => {
+                            Promise.all(promisses || []).then(() => {
+                                this._savingLockers = [];
+                                if (this.saveLoader) {
+                                    const changes = this.getAllChangesToSave();
+                                    this.saveLoader(this, changes).then((records) => {
+                                        const recordsByDataUnit = this.getRecordsByDataUnit(records);
+                                        const dispatchPromisses = [];
+                                        for (const [ownerDataUnitName, splittedRecords] of recordsByDataUnit) {
+                                            const ownerDataUnit = DataUnitStorage.get(ownerDataUnitName);
+                                            const changesByDataUnit = changes.filter(change => change.dataUnit === ownerDataUnitName);
+                                            if (ownerDataUnit) {
+                                                dispatchPromisses.push(ownerDataUnit.dispatchAction(Action.DATA_SAVED, { changes: changesByDataUnit, records: splittedRecords }, executionCtx));
+                                            }
+                                        }
+                                        Promise.all(dispatchPromisses).then(() => resolve());
+                                    }).catch(cause => {
+                                        const { errorCode } = cause;
+                                        fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
+                                    });
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                }
+            }
+            return Promise.resolve();
+        });
+    }
+    /**
+     *
+     * Retorna as alterações a serem salvas no DataUnit atual.
+     *
+     *
+     *
+     * @returns - Mudanças realizadas no DataUnit atual
+     *
+    */
+    buildChangesToSave() {
+        return getChangesToSave(this._name, this._stateManager);
+    }
+    buildChangesToSaveFromChild(allChanges, dataUnit) {
+        var _a;
+        (_a = dataUnit._childByName) === null || _a === void 0 ? void 0 : _a.forEach((dataUnitChild) => {
+            if (dataUnitChild.isDirty()) {
+                allChanges.push(...getChangesToSave(dataUnitChild.name, dataUnitChild._stateManager));
+                this.buildChangesToSaveFromChild(allChanges, dataUnitChild);
+            }
+        });
+    }
+    /**
+     *
+     * Retorna todas as alterações do DataUnit a serem salvas, incluindo no nível Master e Detail.
+     *
+     *
+     *
+     * @returns - Todas as mudanças realizadas no DataUnit, tanto Master quanto Detail;
+     *
+    */
+    getAllChangesToSave() {
+        const allChanges = [];
+        allChanges.push(...this.buildChangesToSave());
+        this.buildChangesToSaveFromChild(allChanges, this);
+        return allChanges;
+    }
+    /**
+     *
+     * Remove o registro selecionado.
+     *
+     * @param buffered - Se será utilizado buffer na solicitação.
+     * @param silent - Define se haverá mensagem de confirmação da remoção
+     *
+     * @returns - ID's dos registros removidos.
+     *
+    */
+    removeSelectedRecords(buffered = false, silent = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selection = this.getSelectionInfo();
+            if (selection) {
+                if (selection.isAllRecords()) {
+                    throw new Error("Exclusão remota não implementada.");
+                }
+                const records = (selection === null || selection === void 0 ? void 0 : selection.records) || [];
+                const recordIds = (selection === null || selection === void 0 ? void 0 : selection.recordIds) || [];
+                return this.removeRecords(recordIds, records, buffered, undefined, silent);
+            }
+            return Promise.resolve([]);
+        });
+    }
+    /**
+     *
+     * Efetua requisição para remoção dos registros.
+     *
+     * @param recordIds - Lista de IDs dos registros que serão removidos.
+     * @param cachedRecords - Dados dos registros que serão removidos.
+     * @param buffered - Se será utilizado buffer na solicitação.
+     * @param executionCtx - Contexto de execução da remoção do registro do DataUnit.
+     * @param silent - Define se haverá mensagem de confirmação da remoção
+     *
+     * @returns - ID's dos registros removidos.
+     *
+    */
+    removeRecords(recordIds, cachedRecords, buffered = false, executionCtx, silent = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (recordIds) {
+                if (buffered || !this.removeLoader) {
+                    this.dispatchAction(Action.RECORDS_REMOVED, { records: recordIds, cachedRecords, buffered: true }, executionCtx);
+                }
+                else {
+                    if (yield this.dispatchAction(Action.REMOVING_RECORDS, { silent }, executionCtx)) {
+                        return new Promise((resolve, fail) => {
+                            if (this.removeLoader) {
+                                this.removeLoader(this, recordIds).then(removedIds => {
+                                    let currentIndex = 0;
+                                    const removedIndex = [];
+                                    const currentRecords = getCurrentRecords(this._stateManager);
+                                    currentRecords.forEach((value, key) => {
+                                        if (removedIds.includes(key)) {
+                                            removedIndex.push(currentIndex);
+                                        }
+                                        currentIndex++;
+                                    });
+                                    this.dispatchAction(Action.RECORDS_REMOVED, { records: removedIds, cachedRecords, removedIndex, buffered: false }, executionCtx);
+                                    resolve(removedIds);
+                                }).catch(error => {
+                                    const { errorCode } = error;
+                                    fail(new ErrorException("Erro ao remover registros", error, errorCode));
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            return Promise.resolve(recordIds);
+        });
+    }
+    // API
+    /**
+     *
+     * Obtém o valor do campo em seu formato/tipo correto a partir de uma string.
+     *
+     * @param fieldName - Nome do campo que terá o tipo identificado para conversão.
+     * @param value - Texto que será convertido de acordo com o tipo identificado no campo.
+     *
+     * @returns - Valor convertido ou ele mesmo.
+     *
+    */
+    valueFromString(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, value) : value;
+    }
+    /**
+     *
+     * Converte o valor informado para texto de acordo com o tipo do campo informado.
+     *
+     * @param fieldName - Nome do campo utilizado para buscar o tipo de dado com o padrão de conversão para string.
+     * @param value - Valor a ser convertido.
+     *
+     * @returns - Valor informado convertido.
+     *
+    */
+    valueToString(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        return toString(descriptor === null || descriptor === void 0 ? void 0 : descriptor.dataType, value);
+    }
+    /**
+     *
+     * Formata o valor do campo considerando as informações do descriptor.
+     * Diferente do método "valueToString" que retorna o dado em valor textual,
+     * getFormattedValue retorna uma informação amigável ao usuário, geralmente
+     * usada na interface.
+     *
+     * @param fieldName - Nome do campo utilizado do qual se quer obter valor.
+     * @param value (opcional) - O valor a ser convertido. Caso omitido pega do registro selecionado.
+     *
+     * @returns - Valor formatado.
+     *
+    */
+    getFormattedValue(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        if (value == undefined) {
+            value = this.getFieldValue(fieldName);
+        }
+        else if (typeof value === "string" && (descriptor === null || descriptor === void 0 ? void 0 : descriptor.dataType) != DataType.TEXT) {
+            value = this.valueFromString(fieldName, value);
+        }
+        if (value == undefined) {
+            return "";
+        }
+        return getFormattedValue(value, descriptor);
+    }
+    /**
+     *
+     * Adiciona um interceptor correspondente a uma ação do DataUnit para fazer um processamento customizado.
+     *
+     * @param interceptor - Interceptor a ser adicionado.
+     *
+    */
+    addInterceptor(interceptor) {
+        this._interceptors.push(interceptor);
+    }
+    /**
+     *
+     * Remove um interceptor da lista de interceptors.
+     *
+     * @param interceptor - Interceptor a ser removido.
+     *
+    */
+    removeInterceptor(interceptor) {
+        this._interceptors = this._interceptors.filter(i => i !== interceptor);
+    }
+    /**
+     *
+     * Adiciona um FilterProvider.
+     *
+     * @param provider - FilterProvider que será adicionado.
+     *
+    */
+    addFilterProvider(provider) {
+        this._filterProviders.set(this.getFielterProviderKey(provider), provider);
+    }
+    /**
+     *
+     * Obtém informações de paginação dos registros.
+     *
+     * @returns - Informações da paginação de registros.
+    */
+    getPaginationInfo() {
+        return getPaginationInfo(this._stateManager);
+    }
+    /**
+     *
+     * Define a lógica de ordenação dos registros.
+     *
+     * @param provider - Objeto usado para definir a propriedade sortingProvider da instância da classe.
+     *
+     */
+    set sortingProvider(provider) {
+        this._sortingProvider = provider;
+    }
+    /**
+     *
+     * Define a propriedade metadata da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
+     *
+     */
+    set metadata(md) {
+        this.dispatchAction(Action.METADATA_LOADED, md, undefined);
+    }
+    /**
+     *
+     * Obtém os metadados do DataUnit.
+     *
+     */
+    get metadata() {
+        return getMetadata(this._stateManager);
+    }
+    /**
+    *
+    * Obtém informações da ligação para um DataUnit filho.
+    *
+    * @param name - Nome do DataUnit que se deseja.
+    *
+    * @returns - As informações sobre a ligação solicitada. Pode retornar undefined.
+    *
+    */
+    getChildInfo(name) {
+        var _a;
+        const children = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.children;
+        if (children == undefined) {
+            return;
+        }
+        return children.find(child => child.name === name);
+    }
+    /**
+     *
+     * Define a propriedade records da instância da classe com um novo valor e chama o método dispatchAction para notificar os observers da aplicação sobre a mudança.
+     *
+     */
+    set records(records) {
+        this.dispatchAction(Action.DATA_LOADED, { records }, undefined);
+    }
+    /**
+     *
+     * Obtém todos os registros atuais.
+     *
+     * @returns - Todos os registros atuais.
+     *
+     */
+    get records() {
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+    /**
+     *
+     * Define a quantidade de registros que será exibido por página.
+     *
+     * @param size - Quantidade de registros que será exibido por página.
+     *
+     */
+    set pageSize(size) {
+        this._pageSize = size;
+    }
+    /**
+     *
+     * Obtém a quantidade de registros que está sendo exibido por página.
+     *
+     * @returns - Quantidade de registros exibidos por página.
+     *
+     */
+    get pageSize() {
+        return this._pageSize;
+    }
+    /**
+     *
+     * Obtém os registros modificados e ainda não salvos no DataUnit.
+     *
+     * @returns - Lista dos registros em edição.
+     *
+     */
+    getModifiedRecords() {
+        const modified = getModifiedRecords(this._stateManager);
+        return modified || [];
+    }
+    /**
+     *
+     * Obtém os registros adicionados no DataUnit.
+     *
+     * @returns - Lista dos registros adicionados.
+     *
+     */
+    getAddedRecords() {
+        return getAddedRecords(this._stateManager);
+    }
+    /**
+     *
+     * Obtém metadados de um campo específico.
+     *
+     * @param fieldName - Identificador do campo.
+     *
+     * @returns - Metadados do campo informado.
+     */
+    getField(fieldName) {
+        return getField(this._stateManager, fieldName);
+    }
+    /**
+     *
+     * Adiciona um novo registro.
+     *
+     * @param executionCtx - Contexto de execução da inserção do dado no DataUnit.
+     *
+    */
+    addRecord(executionCtx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}], this.getParentRecordId()), executionCtx);
+        });
+    }
+    /**
+     *
+     * Efetua a cópia do registro selecionado.
+     *
+     * @param executionCtx - Contexto de execução da cópia do dado do DataUnit.
+     *
+    */
+    copySelected(executionCtx) {
+        const selectionInfo = this.getSelectionInfo();
+        if (selectionInfo) {
+            const selectedRecords = selectionInfo.records;
+            if (selectedRecords) {
+                this.dispatchAction(Action.RECORDS_COPIED, prepareCopiedRecord(this._stateManager, selectedRecords, this.getParentRecordId()), executionCtx);
+            }
+        }
+    }
+    getRecordsByDataUnit(records) {
+        const recordsMap = new Map();
+        records.forEach(record => {
+            let { __owner__dataunit__name__: ownerDataUnitName } = record;
+            if (!ownerDataUnitName) {
+                ownerDataUnitName = this.name;
+            }
+            let changes = recordsMap.get(ownerDataUnitName);
+            if (!changes) {
+                changes = [];
+                recordsMap.set(ownerDataUnitName, changes);
+            }
+            changes.push(record);
+        });
+        return recordsMap;
+    }
+    getParentRecordId() {
+        var _a;
+        const parentRecord = (_a = this._parentDataUnit) === null || _a === void 0 ? void 0 : _a.getSelectedRecord();
+        return parentRecord === null || parentRecord === void 0 ? void 0 : parentRecord.__record__id__;
+    }
+    /**
+     *
+     * Retorna se a alteração no campo já foi concluída ou se ainda está incompleta.
+     *
+     * @param fieldName - Identificador do campo a ser verificado.
+     *
+     * @returns - Verdadeiro se ainda está pendente.
+     *
+    */
+    waitingForChange(fieldName) {
+        return isWaiting(this._stateManager, fieldName);
+    }
+    /**
+     *
+     * Obtém valor do campo desejado.
+     *
+     * @param fieldName - Identificador do campo a ser buscado.
+     *
+     * @returns - Valor do campo.
+     *
+    */
+    getFieldValue(fieldName) {
+        return getFieldValue(this._stateManager, fieldName);
+    }
+    /**
+     *
+     *  Insere valor no campo desejado.
+     *
+     * @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.
+     * @returns - Promise que será resolvida quando o novo valor for persistido no state.
+     *
+    */
+    setFieldValue(fieldName, newValue, records) {
+        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) {
+                const promise = new Promise(accept => {
+                    newValue.then(resolvedValue => {
+                        this.dispatchAction(Action.DATA_RESOLVED, { [fieldName]: resolvedValue, records }, undefined);
+                        accept(this.setFieldValue(fieldName, resolvedValue, records));
+                    });
+                });
+                this._savingLockers.push(promise);
+                return promise;
+            }
+            if (currentValue !== typedValue) {
+                const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined);
+                this._savingLockers.push(promise);
+                return promise;
+            }
+            return Promise.resolve(false);
+        });
+    }
+    /**
+     *
+     *  Marca campos como inválidos.
+     *
+     * @param fieldName - Nome do campo inválido.
+     * @param message - Mensagem descrevendo o motivo da invalidade.
+     * @param recordId - Indica qual registro está com o campo inválido.
+     *
+    */
+    setInvalidField(fieldName, message, recordId) {
+        this.dispatchAction(Action.FIELD_INVALIDATED, { fieldName, message, recordId }, undefined);
+    }
+    /**
+     *
+     *  Limpa campos inválidos.
+     *
+     * @param recordId - Indica em qual registro o campo não está mais inválido.
+     * @param fieldName - Nome do campo. Caso omitido, todos os campos serão limpos.
+     *
+    */
+    clearInvalid(recordId, fieldName) {
+        this.dispatchAction(Action.INVALIDATE_CLEAN, { fieldName, recordId }, undefined);
+    }
+    /**
+     *
+     *  Obtém a mensagem de campo inválido para determinado registro.
+     *
+     * @param recordId - Identificador do registro.
+     * @param fieldName - Nome do campo.
+     *
+    */
+    getInvalidMessage(recordId, fieldName) {
+        return getInvalidFieldMessage(this._stateManager, fieldName, recordId);
+    }
+    /**
+     *
+     *  Inicia alteração no campo.
+     *
+     * @param fieldName - Identificador do campo a ser modificado.
+     * @param waitingChange - Informa que uma mudança irá iniciar.
+     *
+    */
+    startChange(fieldName, waitingChange) {
+        this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
+    }
+    /**
+     *
+     *  Cancela o início de uma alteração no campo.
+     *
+     * @param fieldName - Identificador do campo.
+     *
+    */
+    cancelWaitingChange(fieldName) {
+        this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
+    }
+    /**
+     * Retorna se existe alterações pendentes.
+     * @returns Verdadeiro se existir pendências de modificações.
+    */
+    hasWaitingChanges() {
+        const waitingChanges = getWaitingChanges(this._stateManager);
+        return waitingChanges ? !!waitingChanges.size : false;
+    }
+    /**
+     *
+     * Seleciona o primeiro registro.
+     *
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     *
+    */
+    selectFirst(executionCtx) {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([0], executionCtx);
+        }
+    }
+    /**
+     *
+     * Seleciona o último registro.
+     *
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     *
+    */
+    selectLast(executionCtx) {
+        if (this.records.length > 0) {
+            this.setSelectionByIndex([this.records.length - 1], executionCtx);
+        }
+    }
+    /**
+     *
+     * Seleciona múltiplos registros por índice.
+     *
+     * @param selection - Índices desejados para a seleção.
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     *
+    */
+    setSelectionByIndex(selection, executionCtx) {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
+    }
+    /**
+     *
+     * Seleciona múltiplos registros por ID ou todos os registros (multipágina) .
+     *
+     * @param selection - IDs para selecionar ou o modo de seleção completo.
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     *
+     *
+    */
+    setSelection(selection, executionCtx) {
+        return new Promise(resolve => {
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx)
+                .then(() => resolve(getSelectionInfo(this._stateManager)));
+        });
+    }
+    /**
+     *
+     * Limpa a seleção.
+     *
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     *
+    */
+    clearSelection(executionCtx) {
+        this.setSelection([], executionCtx);
+    }
+    /**
+     *
+     * Atualiza a seleção dos registros atuais.
+     *
+     * @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) {
+            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);
+                }
+            });
+            this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection: Array.from(newSelection) }, executionCtx)
+                .then(() => {
+                resolve(this.getSelectionInfo());
+            });
+        });
+    }
+    /**
+     *
+     * Obtém informações sobre a seleção atual.
+     *
+     * @returns - Objeto com informações como registros selecionados e seleção por critério.
+     *
+     **/
+    getSelectionInfo() {
+        return getSelectionInfo(this._stateManager);
+    }
+    /**
+     *
+     * Retorna apenas um registro selecionado no Dataunit
+     *
+     * @returns - Registro selecionado.
+     *
+    */
+    getSelectedRecord() {
+        const selection = getSelectionRecords(this._stateManager);
+        if (!selection || selection.length == 0)
+            return;
+        return selection[0];
+    }
+    /**
+     *
+     * Limpa todos os registros do DataUnit
+     *
+     *
+    */
+    clearDataUnit() {
+        this.records = [];
+    }
+    /**
+     *
+     * Seleciona o próximo registro.
+     *
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     *
+     *
+    */
+    nextRecord(executionCtx) {
+        if (!hasNext(this._stateManager)) {
+            if (hasMorePages(this._stateManager)) {
+                this.nextPage({
+                    before: act => {
+                        if (executionCtx && executionCtx.before) {
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectFirst(executionCtx);
+                    }
+                });
+            }
+        }
+        else {
+            this.dispatchAction(Action.NEXT_SELECTED, undefined, executionCtx);
+        }
+    }
+    /**
+     *
+     * Seleciona o registro anterior.
+     *
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     *
+    */
+    previousRecord(executionCtx) {
+        if (!hasPrevious(this._stateManager)) {
+            if (hasPreviousPages(this._stateManager)) {
+                this.previousPage({
+                    before: act => {
+                        if (executionCtx && executionCtx.before) {
+                            act = executionCtx.before(act);
+                        }
+                        return act;
+                    },
+                    after: act => {
+                        this.selectLast(executionCtx);
+                    }
+                });
+            }
+        }
+        else {
+            this.dispatchAction(Action.PREVIOUS_SELECTED, undefined, executionCtx);
+        }
+    }
+    /**
+     *
+     * Cancela edição do registro atual.
+     *
+     * @param executionCtx - Contexto de execução do cancelamento da seleção dos registros.
+     * @param silent: Define se haverá mensagem de confirmação do cancelamento
+     *
+    */
+    cancelEdition(executionCtx, fromParent, silent = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cancelledAction = yield this.dispatchAction(Action.EDITION_CANCELED, { fromParent, silent }, executionCtx);
+            for (const [, dataUnit] of this._childByName) {
+                if (dataUnit.isDirty()) {
+                    dataUnit.cancelEdition(undefined, true, silent);
+                }
+            }
+            return Promise.resolve(cancelledAction);
+        });
+    }
+    /**
+     *
+     * Retorna se existe algum tipo de alteração pendente.
+     *
+     * @returns Verdadeiro se existir alterações pendentes.
+     *
+    */
+    isDirty() {
+        return isDirty(this._stateManager) || this.childrenIsDirty();
+    }
+    /**
+     *
+     * Retorna se existe algum DataUnit detail com alterações pendentes.
+     *
+     * @returns Verdadeiro se existir alterações pendentes em algum DataUnit detail.
+     *
+    */
+    childrenIsDirty() {
+        for (let [key, dataUnitChild] of this._childByName) {
+            if (dataUnitChild.isDirty())
+                return true;
+        }
+        return false;
+    }
+    /**
+     *
+     * Retorna se existe algum registro em modo de edição.
+     *
+     * @returns Verdadeiro se existir alterações de registros pendentes.
+     *
+    */
+    hasDirtyRecords() {
+        return hasDirtyRecords(this._stateManager);
+    }
+    /**
+     *
+     * Retorna se existir uma pagina seguinte a atual na paginação.
+     *
+     * @returns Verdadeiro se existir uma próxima página.
+     *
+    */
+    hasNext() {
+        let result = hasNext(this._stateManager);
+        if (!result) {
+            result = hasMorePages(this._stateManager);
+        }
+        return result;
+    }
+    /**
+     *
+     * Retorna se existe uma página anterior a atual na paginação.
+     *
+     * @returns Verdadeiro se existir uma página anterior.
+     *
+    */
+    hasPrevious() {
+        let result = hasPrevious(this._stateManager);
+        if (!result) {
+            result = hasPreviousPages(this._stateManager);
+        }
+        return result;
+    }
+    /**
+     *
+     * Verifica se um registro é proveniente de inclusão.
+     *
+     * @param recordId - O id do registro a ser verificado.
+     * @returns Verdadeiro se o id solicitado é de um registro novo.
+     *
+    */
+    isNewRecord(recordId) {
+        const newRecords = getAddedRecords(this._stateManager);
+        if (newRecords && newRecords.length > 0) {
+            const record = newRecords.find(newRecord => newRecord.__record__id__ === recordId);
+            return record != undefined;
+        }
+        return false;
+    }
+    /**
+     *
+     * Retorna se existe pelo menos um registro novo.
+     *
+     * @returns Verdadeiro se algum registro foi adicionado.
+     *
+    */
+    hasNewRecord() {
+        const newRecords = getAddedRecords(this._stateManager);
+        return newRecords && newRecords.length > 0;
+    }
+    /**
+     *
+     * Retorna se existe pelo menos um registro novo.
+     *
+     * @returns Verdadeiro se algum registro foi adicionado.
+     *
+    */
+    hasCopiedRecord() {
+        const newRecords = getAddedRecords(this._stateManager);
+        if (newRecords == undefined) {
+            return false;
+        }
+        for (let record of newRecords) {
+            if (record['__record__source__id__'] != undefined) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     * Retorna se a informação do estado anterior está salva, permitindo desfazer a ação.
+     *
+     * @returns Verdadeiro se for possível desfazer a ação.
+     *
+    */
+    canUndo() {
+        return canUndo(this._stateManager);
+    }
+    /**
+     *
+     * Retorna se a informação do estado futuro está salva, permitindo refazer a ação.
+     *
+     * @returns Verdadeiro se for possível refazer a ação.
+     *
+    */
+    canRedo() {
+        return canRedo(this._stateManager);
+    }
+    /**
+     *
+     * Desfaz a última ação.
+     *
+     * @param executionCtx - Contexto de execução de desfazer a última ação.
+     *
+     *
+    */
+    undo(executionCtx) {
+        this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
+    }
+    /**
+     *
+     * Refaz a última ação.
+     *
+     * @param executionCtx - Contexto de execução de refazer a última ação.
+     *
+    */
+    redo(executionCtx) {
+        this.dispatchAction(Action.CHANGE_REDONE, undefined, executionCtx);
+    }
+    /**
+     *
+     * Obtém a representação textual do DataUnit, nesse caso, o nome do DataUnit.
+     *
+     * @returns - Valor contido na propriedade name.
+     *
+    */
+    toString() {
+        return this.name;
+    }
+    // Actions / State manager
+    /**
+     *
+     * Lança ação do DataUnit para que sejam processadas.
+     *
+     * @param actionType - Tipo de ação que será executada.
+     * @param payload - Dados que serão processados na ação.
+     * @param executionCtx - Contexto de execução de lançar a ação que será executada.
+     *
+     * @returns - Verdadeiro se ação iniciada.
+     *
+    */
+    dispatchAction(actionType, payload, executionCtx) {
+        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) {
+                    action = yield this.intercept(action, this._interceptors.values());
+                }
+                if (action) {
+                    this.doDispatchAction(action);
+                    if (executionCtx && executionCtx.after) {
+                        executionCtx.after(action);
+                    }
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            }));
+        });
+    }
+    /**
+     *
+     * Notifica os interceptors de que uma ação foi executada, para que cada interceptor possa fazer sua respectiva tratativa dos dados.
+     *
+     * @param action - Ação que foi executada.
+     * @param interceptors - Interceptors que serão notificados.
+     *
+     * @returns - Ação executada no DataUnit.
+     *
+    */
+    intercept(action, interceptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                let ite;
+                while (action && !(ite = interceptors.next()).done) {
+                    action = yield ite.value.interceptAction(action);
+                }
+                resolve(action);
+            }));
+        });
+    }
+    /**
+     *
+     * Processa as ações no DataUnit e notifica os observers.
+     *
+     * @param action - Ações em execução no DataUnit.
+     *
+    */
+    doDispatchAction(action) {
+        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
+            */
+            try {
+                f(action);
+            }
+            catch (e) {
+                console.warn("[DataUnit] error while call observer", e);
+            }
+        });
+    }
+    /**
+     *
+     * Cria um dataunit filho.
+     *
+     * @param name - Nome do dataunit filho.
+     *
+    */
+    getChildDataunit(name) {
+        const detail = new DataUnit(name, this);
+        this._childByName.set(name, detail);
+        return detail;
+    }
+    /**
+     *
+     * Remove um dataunit filho.
+     *
+     * @param name - Nome do dataunit filho.
+     *
+    */
+    removeChildDataunit(name) {
+        this._childByName.delete(name);
+    }
+    /**
+     *
+     * Adiciona um novo observer no 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.
+     *
+    */
+    subscribe(observer) {
+        this._observers.push(observer);
+    }
+    /**
+     *
+     * Remove um observer existente.
+     *
+     * @param observer - Observer que se deseja remover.
+     *
+    */
+    unsubscribe(observer) {
+        this._observers = this._observers.filter(f => f !== observer);
+    }
+    /**
+     *
+     * Recarrega registro selecionado com dados atualizados do servidor.
+     *
+     * @returns - Dados atualizados do registro selecionado.
+     *
+    */
+    reloadCurrentRecord() {
+        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)
+                return;
+            this.recordLoader(this, selection).then(response => {
+                this.dispatchAction(Action.RECORD_LOADED, response);
+            }).catch(cause => {
+                const { errorCode } = cause;
+                fail(new ErrorException("Erro ao recarregar registro", cause, errorCode));
+            });
+        }));
+    }
+    /**
+     *
+     * Obtém a estrutura de ordenação das colunas dos dados.
+     *
+     * @returns - Lista dos ordenáveis por prioridade.
+     *
+    */
+    getSort() {
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
+    }
+    /**
+     *
+     * Obtém todos os filtros de dados.
+     *
+     * @returns - Lista de filtros.
+     *
+    */
+    getFilters() {
+        let filters = undefined;
+        this._filterProviders.forEach(p => {
+            const f = p.getFilter(this.name);
+            if (f) {
+                filters = (filters || []).concat(f);
+            }
+        });
+        return filters;
+    }
+    /**
+     *
+     * Obtém as informações da última carga de dados.
+     *
+     * @returns - As informações de filtro e paginação.
+     *
+    */
+    getLastLoadRequest() {
+        return getCurrentRequest(this._stateManager);
+    }
+    /**
+     *
+     * Obtém os filtros aplicados.
+     *
+     * @returns - Lista de filtros.
+     *
+    */
+    getAppliedFilters() {
+        const { filters } = getCurrentRequest(this._stateManager) || {};
+        return filters;
+    }
+    /**
+     *
+     * Habilita um campo do DataUnit
+     * @param fieldName - nome do campo para ser habilitado.
+     *
+    */
+    enableField(fieldName) {
+        const fieldDescriptor = this.getField(fieldName);
+        if ((fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.readOnly) === true) {
+            fieldDescriptor.readOnly = false;
+            this.metadata = Object.assign({}, this.metadata);
+        }
+    }
+    /**
+     *
+     * Desabilita um campo do DataUnit
+     * @param fieldName - nome do campo para ficar desabilitado.
+     *
+    */
+    disableField(fieldName) {
+        const fieldDescriptor = this.getField(fieldName);
+        if ((fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.readOnly) === false) {
+            fieldDescriptor.readOnly = true;
+            this.metadata = Object.assign({}, this.metadata);
+        }
+    }
+    /**
+     *
+     * Deixa um campo do DataUnit invisível
+     * @param fieldName - nome do campo para ficar invisível.
+     *
+    */
+    hideField(fieldName) {
+        const fieldDescriptor = this.getField(fieldName);
+        if ((fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.visible) === true) {
+            fieldDescriptor.visible = false;
+            this.metadata = Object.assign({}, this.metadata);
+        }
+    }
+    /**
+     *
+     * Deixa um campo do DataUnit visível
+     * @param fieldName - nome do campo para ficar visível.
+     *
+    */
+    showField(fieldName) {
+        const fieldDescriptor = this.getField(fieldName);
+        if ((fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.visible) === false) {
+            fieldDescriptor.visible = true;
+            this.metadata = Object.assign({}, this.metadata);
+        }
+    }
+    /**
+     *
+     * Obtém todos os registros selecionados.
+     *
+     * @returns - Lista de registros selecionados.
+     *
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     *
+    */
+    getSelectedRecords() {
+        console.warn("DataUnit: O método `getSelectedRecords` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+        if (selection != undefined && selection.isAllRecords()) {
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+        if (selection) {
+            return selection.records;
+        }
+    }
+    /**
+     *
+     * Obtém ids dos registros selecionados.
+     *
+     * @returns - Lista com id de todos os registros selecionados.
+     *
+     * @deprecated - Utilize o método `getSelectionInfo()` para obter os registros selecionados.
+     * Devido a seleção virtual baseada em critérios e ordenação (ALL_RECORDS), esse
+     * método foi descontinuado e pode retornar erros no caso da seleção virtual.
+     *
+    */
+    getSelection() {
+        console.warn("DataUnit: O método `getSelection` foi descontinuado. Use o método `getSelectionInfo`.");
+        const selection = this.getSelectionInfo();
+        if (selection != undefined && selection.isAllRecords()) {
+            throw new Error("Erro interno: Impossível retornar os registros selecionados. A seleção atual é virtual. Use o método `getSelectionInfo`.");
+        }
+        return (selection === null || selection === void 0 ? void 0 : selection.recordIds) || [];
+    }
+    /**
+     * Adiciona um locker para impedir o carregamento dos registros do dataUnit.
+     * @returns Retorna uma função responsável por liberar o lock adicionado.
+     */
+    addLoadingLocker() {
+        let loadingLockerResolver;
+        this._loadingLockers.push(new Promise((resolve) => {
+            loadingLockerResolver = resolve;
+        }));
+        return loadingLockerResolver || Promise.resolve;
+    }
+    processLoadingLockers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._loadingLockers.length) {
+                yield Promise.all(this._loadingLockers);
+                this._loadingLockers = [];
+            }
+        });
+    }
+}
+export var ChangeOperation;
+(function (ChangeOperation) {
+    ChangeOperation["INSERT"] = "INSERT";
+    ChangeOperation["COPY"] = "COPY";
+    ChangeOperation["UPDATE"] = "UPDATE";
+    ChangeOperation["DELETE"] = "DELETE";
+})(ChangeOperation || (ChangeOperation = {}));
+/***
+ * `Change`: Dados que representam uma alteração.
+ */
+export class Change {
+    constructor(dataUnit, record, updates, operation, sourceId) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.sourceId = sourceId;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+    /**
+     *
+     * Obtém o tipo de operação que está sendo realizada.
+     *
+     * @returns - Ação que está sendo executada.
+     *
+     */
+    get operation() {
+        return this._operation.toString();
+    }
+    /**
+     *
+     * Retorna se o DataUnit está em uma operação de inserção.
+     *
+     * @returns - Verdadeiro se a operação for de inserção.
+     *
+     */
+    isInsert() {
+        return this._operation === ChangeOperation.INSERT;
+    }
+    /**
+     *
+     * Retorna se o DataUnit está em uma operação de cópia.
+     *
+     * @returns - Verdadeiro se a operação for de cópia.
+     *
+     */
+    isCopy() {
+        return this._operation === ChangeOperation.COPY;
+    }
+    /**
+     *
+     * Retorna se o DataUnit está em uma operação de deleção.
+     *
+     * @returns - Verdadeiro se a operação for de deleção.
+     *
+     */
+    isDelete() {
+        return this._operation === ChangeOperation.DELETE;
+    }
+    /**
+     *
+     * Retorna se o DataUnit está em uma operação de atualização.
+     *
+     * @returns - Verdadeiro se a operação for de atualização.
+     *
+     */
+    isUpdate() {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+}
+export var SelectionMode;
+(function (SelectionMode) {
+    SelectionMode["ALL_RECORDS"] = "ALL_RECORDS";
+    SelectionMode["SOME_RECORDS"] = "SOME_RECORDS";
+})(SelectionMode || (SelectionMode = {}));
+export class SelectionInfo {
+    constructor(records, mode = SelectionMode.SOME_RECORDS, total, filters, sort) {
+        this._records = records;
+        this._total = total;
+        this.mode = mode;
+        this.filters = filters;
+        this.sort = sort;
+    }
+    get records() {
+        if (this.isAllRecords()) {
+            throw new Error("Erro interno: [ALL_RECORDS] - Impossível retornar os registros selecionados numa seleção virtual.");
+        }
+        return this._records;
+    }
+    get recordIds() {
+        const records = this.records;
+        if (records == undefined) {
+            return undefined;
+        }
+        return records.map(record => record.__record__id__);
+    }
+    get length() {
+        if (this.isAllRecords()) {
+            return this._total || 0;
+        }
+        return this.records == undefined ? 0 : this.records.length;
+    }
+    isAllRecords() {
+        return this.mode === SelectionMode.ALL_RECORDS;
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+}
+//# sourceMappingURL=DataUnit.js.map