@sankhyalabs/core 2.3.6 → 2.4.0

package/src/dataunit/DataUnit.ts

@@ -21,6 +21,9 @@ import { getField, getMetadata, UnitMetadataReducer } from "./state/slice/UnitMe
 import { getBlockingWaitingChanges, getWaitingChangePromisses, isWaiting, WaitingChangesReducer } from "./state/slice/WaitingChangesSlice.js";
 import { canRedo, canUndo, HistReducer } from "./state/HistReducer.js";
 
+/***
+ * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
+ */
 export default class DataUnit {
 
     private _name: string;
@@ -31,11 +34,11 @@ export default class DataUnit {
     private _interceptors: Array<DUActionInterceptor>;
     private _pageSize: number;
 
-    public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
-    public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
-    public saveLoader?: (dataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
-    public removeLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
-    public recordLoader?: (dataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
+    public metadataLoader?: (DataUnit: DataUnit) => Promise<UnitMetadata>;
+    public dataLoader?: (DataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
+    public saveLoader?: (DataUnit: DataUnit, changes: Array<Change>) => Promise<Array<SavedRecord>>;
+    public removeLoader?: (DataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<string>>;
+    public recordLoader?: (DataUnit: DataUnit, recordIds: Array<string>) => Promise<Array<Record>>;
 
     constructor(name: string) {
         this._name = name;
@@ -60,16 +63,40 @@ export default class DataUnit {
         this._interceptors = [];
     }
 
+    /**
+     * 
+     * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
+     * 
+     * @returns - Nome de identificação do DataUnit.
+     * 
+    */
     public get name(): string {
         return this._name;
     }
 
-    // Métodos privados
+    /**
+     * 
+     * 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.
+     * 
+    */
     private validateAndTypeValue(fieldName: string, newValue: any): any {
         const descriptor: FieldDescriptor | undefined = this.getField(fieldName);
         return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
     }
 
+
+    /**
+     * 
+     * Obtém todos os filtros de dados.
+     * 
+     * @returns - Lista de filtros.
+     * 
+    */
     private getFilters(): Array<Filter> | undefined {
         let filters: Array<Filter> | undefined = undefined;
         this._filterProviders.forEach(p => {
@@ -81,10 +108,26 @@ export default class DataUnit {
         return filters;
     }
 
+    /**
+     * 
+     * Obtém a estrutura de ordenação das colunas dos dados.
+     * 
+     * @returns - Lista dos ordenáveis por prioridade.
+     * 
+    */
     private getSort(): Array<Sort> | undefined {
         return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
     }
 
+    /**
+     * 
+     * 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.
+     * 
+    */
     private getFielterProviderKey(provider: FilterProvider): string {
         if (provider.getKey) {
             return provider.getKey();
@@ -92,6 +135,16 @@ export default class DataUnit {
         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.
+     * 
+     * @returns - Registros do DataUnit.
+     * 
+    */
     private executeLoadData(request: LoadDataRequest, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
         return new Promise(async (resolve, fail) => {
             if (await this.dispatchAction(Action.LOADING_DATA, request, executionCtx)) {
@@ -111,6 +164,15 @@ export default class DataUnit {
     }
 
     // Loaders
+    /**
+     * 
+     * Carrega os metadados do DataUnit.
+     * 
+     * @param executionCtx - Contexto de execução do carregamento dos metadados do DataUnit.
+     * 
+     * @returns - Metadados carregados.
+     * 
+    */
     public async loadMetadata(executionCtx?: ExecutionContext): Promise<UnitMetadata | void> {
         if (await this.dispatchAction(Action.LOADING_METADATA, undefined, executionCtx)) {
             return new Promise((resolve, fail) => {
@@ -129,6 +191,16 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * Carrega os registros do DataUnit.
+     * 
+     * @param quickFilter - Filtros a serem aplicados.
+     * @param executionCtx - Contexto de execução do carregamento dos registros.
+     * 
+     * @returns - Registros requisitados.
+     * 
+    */
     public async loadData(quickFilter?: QuickFilter, executionCtx?: ExecutionContext): Promise<LoadDataResponse> {
 
         const loadDataRequest: LoadDataRequest = {
@@ -145,6 +217,16 @@ export default class DataUnit {
         return this.executeLoadData(loadDataRequest, executionCtx);
     }
 
+    /**
+     * 
+     * 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.
+     * 
+    */
     public async gotoPage(page: number, executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
 
         let request = getCurrentRequest(this._stateManager);
@@ -165,14 +247,41 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * 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.
+     * 
+    */
     public async nextPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
         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.
+     * 
+    */
     public async previousPage(executionCtx?: ExecutionContext): Promise<LoadDataResponse | void> {
         return this.gotoPage(getCurrentPage(this._stateManager) - 1, executionCtx);
     }
 
+    /**
+     * 
+     * Salva o estado do registro do DataUnit.
+     * 
+     * @param executionCtx - Contexto de execução da persistencia do registro do DataUnit.
+     * 
+     * @returns - Resposta da solicitação.
+     * 
+    */
     public async saveData(executionCtx?: ExecutionContext): Promise<void> {
         const blockingWaitingChanges = getBlockingWaitingChanges(this._stateManager);
 
@@ -209,6 +318,15 @@ export default class DataUnit {
         return Promise.resolve();
     }
 
+    /**
+     * 
+     * Remove o registro selecionado.
+     * 
+     * @param buffered - Se será utilizado buffer na solicitação.
+     * 
+     * @returns - ID's dos registros removidos.
+     * 
+    */
     public async removeSelectedRecords(buffered: boolean = false): Promise<Array<string>> {
         const selection = getSelection(this._stateManager);
         if (selection) {
@@ -218,6 +336,18 @@ export default class DataUnit {
         return Promise.resolve(selection);
     }
 
+    /**
+     * 
+     * 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.
+     * 
+     * @returns - ID's dos registros removidos.
+     * 
+    */
     public async removeRecords(recordIds: Array<string>, cachedRecords: Array<Record>, buffered: boolean = false, executionCtx?: ExecutionContext): Promise<Array<string>> {
         if (recordIds) {
             if (buffered || !this.removeLoader) {
@@ -257,74 +387,193 @@ export default class DataUnit {
     }
 
     // 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.
+     * 
+    */
     public valueFromString(fieldName: string, value: string): any {
         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.
+     * 
+    */
     public valueToString(fieldName: string, value: any): string {
         const descriptor = this.getField(fieldName);
         return toString(descriptor?.dataType, value);
     }
 
+    /**
+     * 
+     * Adiciona um interceptor correspondente a uma ação do DataUnit para fazer um processamento customizado.
+     * 
+     * @param interceptor - Interceptor a ser adicionado.
+     * 
+    */
     public addInterceptor(interceptor: DUActionInterceptor): void {
         this._interceptors.push(interceptor);
     }
 
+    /**
+     * 
+     * Remove um interceptor da lista de interceptors.
+     * 
+     * @param interceptor - Interceptor a ser removido.
+     * 
+    */
     public removeInterceptor(interceptor: DUActionInterceptor) {
         this._interceptors = this._interceptors.filter(i => i !== interceptor);
     }
 
+    /**
+     * 
+     * Adiciona um FilterProvider.
+     * 
+     * @param provider - FilterProvider que será adicionado.
+     * 
+    */
     public addFilterProvider(provider: FilterProvider): void {
         this._filterProviders.set(this.getFielterProviderKey(provider), provider);
     }
 
+    /**
+     * 
+     * Obtém informações de paginação dos registros.
+     * 
+     * @returns - Informações da paginação de registros. 
+    */
     public getPaginationInfo(): PaginationInfo | void {
         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.
+     * 
+     */
     public set sortingProvider(provider: SortingProvider) {
         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.
+     * 
+     */
     public set metadata(md: UnitMetadata) {
         this.dispatchAction(Action.METADATA_LOADED, md, undefined);
     }
 
+    /**
+     * 
+     * Obtém os metadados do DataUnit.
+     * 
+     */
     public get metadata(): UnitMetadata {
         return getMetadata(this._stateManager);
     }
 
+    /**
+     * 
+     * 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.
+     * 
+     */
     public set records(r: Array<Record>) {
         this.dispatchAction(Action.DATA_LOADED, { records: this.records }, undefined);
     }
 
+    /**
+     * 
+     * Obtém todos os registros atuais.
+     * 
+     * @returns - Todos os registros atuais.
+     * 
+     */
     public get records(): Array<Record> {
         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.
+     * 
+     */
     public set pageSize(size: number) {
         this._pageSize = size;
     }
 
+    /**
+     * 
+     * Obtém a quantidade de registros que está sendo exibido por página.
+     * 
+     * @returns - Quantidade de registros exibidos por página.
+     * 
+     */
     public get pageSize(): number {
         return this._pageSize;
     }
 
+    /**
+     * 
+     * Obtém os registros modificados e ainda não salvos no DataUnit.
+     * 
+     * @returns - Lista dos registros em edição.
+     * 
+     */
     public getModifiedRecords(): Array<Record> {
         const modified = getModifiedRecords(this._stateManager);
         return modified || [];
     }
 
+    /**
+     * 
+     * Obtém metadados de um campo específico.
+     * 
+     * @param fieldName - Identificador do campo.
+     * 
+     * @returns - Metadados do campo informado.
+     */
     public getField(fieldName: string): FieldDescriptor | undefined {
         return getField(this._stateManager, fieldName);
     }
 
+    /**
+     * 
+     * Adiciona um novo registro.
+     * 
+     * @param executionCtx - Contexto de execução da inserção do dado no DataUnit.
+     * 
+    */
     public addRecord(executionCtx?: ExecutionContext): void {
         this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]), executionCtx);
     }
 
+    /**
+     * 
+     * Efetua a cópia do registro selecionado.
+     * 
+     * @param executionCtx - Contexto de execução da cópia do dado do DataUnit.
+     * 
+    */
     public copySelected(executionCtx?: ExecutionContext): void {
         const selectedRecords = this.getSelectedRecords();
         if (selectedRecords) {
@@ -332,14 +581,41 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * 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.
+     * 
+    */
     public waitingForChange(fieldName: string): boolean {
         return isWaiting(this._stateManager, fieldName);
     }
 
+    /**
+     * 
+     * Obtém valor do campo desejado.
+     * 
+     * @param fieldName - Identificador do campo a ser buscado.
+     * 
+     * @returns - Valor do campo.
+     * 
+    */
     public getFieldValue(fieldName: string): any {
         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.
+     * 
+    */
     public setFieldValue(fieldName: string, newValue: any, records?: Array<string>): void {
 
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
@@ -350,38 +626,98 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     *  Inicia alteração no campo.
+     * 
+     * @param fieldName - Identificador do campo a ser modificado.
+     * @param waitingChange - Informa que uma mudança irá iniciar.
+     * 
+    */
     public startChange(fieldName: string, waitingChange: WaitingChange): void {
         this.dispatchAction(Action.CHANGING_DATA, { [fieldName]: waitingChange }, undefined);
     }
 
+    /**
+     * 
+     *  Cancela o início de uma alteração no campo.
+     * 
+     * @param fieldName - Identificador do campo.
+     * 
+    */
     public cancelWaitingChange(fieldName: string): void {
         this.dispatchAction(Action.WAITING_CHANGE_CANCELED, { fieldName }, undefined);
     }
 
+    /**
+     * 
+     *  Obtém registros selecionados.
+     * 
+     * @returns - Registros selecionados.
+     * 
+    */
     public getSelection(): Array<string> {
         return getSelection(this._stateManager);
     }
 
+    /**
+     * 
+     * Seleciona múltiplos registros por ID.
+     * 
+     * @param selection - IDs para selecionar.
+     * @param executionCtx - Contexto de execução da seleção dos registros do DataUnit.
+     * 
+    */
     public setSelection(selection: Array<string>, executionCtx?: ExecutionContext): void {
         this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection }, executionCtx);
     }
 
+    /**
+     * 
+     * Seleciona o primeiro registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
     public selectFirst(executionCtx?: ExecutionContext): void {
         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.
+     * 
+    */
     public selectLast(executionCtx?: ExecutionContext): void {
         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.
+     * 
+    */
     public setSelectionByIndex(selection: Array<number>, executionCtx?: ExecutionContext): void {
         this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection }, executionCtx);
     }
 
+    /**
+     * 
+     * Obtém todos os registros selecionados.
+     * 
+     * @returns - Lista de registros selecionados.
+     * 
+    */
     public getSelectedRecords(): Array<Record> | undefined {
         const selection: Array<string> = this.getSelection();
         if (selection) {
@@ -390,6 +726,14 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * Seleciona o próximo registro.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+     * 
+    */
     public nextRecord(executionCtx?: ExecutionContext): void {
         if(!hasNext(this._stateManager)){
             if(hasMorePages(this._stateManager)){
@@ -410,6 +754,13 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * Seleciona o registro anterior.
+     * 
+     * @param executionCtx - Contexto de execução da seleção do registro do DataUnit.
+     * 
+    */
     public previousRecord(executionCtx?: ExecutionContext): void {
         if(!hasPrevious(this._stateManager)){
             if(hasPreviousPages(this._stateManager)){
@@ -430,18 +781,46 @@ export default class DataUnit {
         }
     }
 
+    /**
+     * 
+     * Cancela edição do registro atual.
+     * 
+     * @param executionCtx - Contexto de execução do cancelamento da seleção dos registros.
+     * 
+    */
     public cancelEdition(executionCtx?: ExecutionContext): void {
         this.dispatchAction(Action.EDITION_CANCELED, undefined, executionCtx);
     }
 
+    /**
+     * 
+     * Retorna se existe algum tipo de alteração pendente.
+     * 
+     * @returns Verdadeiro se existir alterações pendentes.
+     * 
+    */
     public isDirty(): boolean {
         return isDirty(this._stateManager);
     }
 
+    /**
+     * 
+     * Retorna se existe algum registro em modo de edição.
+     * 
+     * @returns Verdadeiro se existir alterações de registros pendentes.
+     * 
+    */
     public hasDirtyRecords(): boolean {
         return hasDirtyRecords(this._stateManager);
     }
 
+    /**
+     * 
+     * Retorna se existir uma pagina seguinte a atual na paginação.
+     * 
+     * @returns Verdadeiro se existir uma próxima página.
+     * 
+    */
     public hasNext(): boolean {
         let result = hasNext(this._stateManager);
         if(!result){
@@ -450,6 +829,13 @@ export default class DataUnit {
         return result;
     }
 
+    /**
+     * 
+     * Retorna se existe uma página anterior a atual na paginação.
+     * 
+     * @returns Verdadeiro se existir uma página anterior.
+     * 
+    */
     public hasPrevious(): boolean {
         let result = hasPrevious(this._stateManager);
         if(!result){
@@ -458,27 +844,74 @@ export default class DataUnit {
         return result;
     }
 
+    /**
+     * 
+     * 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.
+     * 
+    */
     public canUndo(): boolean {
         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.
+     * 
+    */
     public canRedo(): boolean {
         return canRedo(this._stateManager);
     }
 
+    /**
+     * 
+     * Desfaz a última ação.
+     * 
+     * @param executionCtx - Contexto de execução de desfazer a última ação.
+     * 
+     * 
+    */
     public undo(executionCtx?: ExecutionContext) {
         this.dispatchAction(Action.CHANGE_UNDONE, undefined, executionCtx);
     }
 
+    /**
+     * 
+     * Refaz a última ação.
+     * 
+     * @param executionCtx - Contexto de execução de refazer a última ação.
+     * 
+    */
     public redo(executionCtx?: ExecutionContext) {
         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. 
+     * 
+    */
     public 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.
+     * 
+    */
     private async dispatchAction(actionType: Action, payload?: any, executionCtx?: ExecutionContext): Promise<boolean> {
         return new Promise(async resolve => {
             let action = new DataUnitAction(actionType, payload);
@@ -500,6 +933,16 @@ export default class DataUnit {
         });
     }
 
+    /**
+     *  
+     * 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.
+     * 
+    */
     private async intercept(action: DataUnitAction, interceptors: IterableIterator<DUActionInterceptor>): Promise<DataUnitAction> {
         return new Promise(async resolve => {
             let ite;
@@ -510,7 +953,14 @@ export default class DataUnit {
         });
     }
 
-    private doDispatchAction(action: DataUnitAction) {
+    /**
+     *  
+     * Processa as ações no DataUnit e notifica os observers.
+     * 
+     * @param action - Ações em execução no DataUnit.
+     * 
+    */
+    private doDispatchAction(action: DataUnitAction): void {
         this._stateManager.process(action);
         this._observers.forEach(f => {
             /* 
@@ -525,14 +975,36 @@ export default class DataUnit {
         });
     }
 
+    /**
+     *  
+     * 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.
+     * 
+    */
     public subscribe(observer: (action: DataUnitAction) => void) {
         this._observers.push(observer);
     }
 
+    /**
+     *  
+     * Remove um observer existente.
+     * 
+     * @param observer - Observer que se deseja remover.
+     * 
+    */
     public unsubscribe(observer: Function) {
         this._observers = this._observers.filter(f => f !== observer);
     }
 
+    /**
+     * 
+     * Recarrega registro selecionado com dados atualizados do servidor.
+     * 
+     * @returns - Dados atualizados do registro selecionado.
+     *      
+    */
     public reloadCurrentRecord(): Promise<Array<Record>>{        
         return new Promise(async (resolve, fail) => {
             const selection = this.getSelection();
@@ -572,39 +1044,77 @@ export enum ChangeOperation {
     DELETE = "DELETE",
 }
 
+/***
+ * `Change`: Dados que representam uma alteração.
+ */
 export class Change {
 
-    public dataUnit: string;
+    public DataUnit: string;
     public record: Record;
     public sourceId: string | undefined;
     public updatingFields: any;
 
     private _operation: ChangeOperation;
 
-    constructor(dataUnit: string, record: Record, updates: any, operation: ChangeOperation, sourceId?: string) {
-        this.dataUnit = dataUnit;
+    constructor(DataUnit: string, record: Record, updates: any, operation: ChangeOperation, sourceId?: string) {
+        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.
+     * 
+     */
     public get operation(): string {
         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.
+     * 
+     */
     public isInsert(): boolean {
         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.
+     * 
+     */
     public isCopy(): boolean {
         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.
+     * 
+     */
     public isDelete(): boolean {
         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.
+     * 
+     */
     public isUpdate(): boolean {
         return this._operation === ChangeOperation.UPDATE;
     }